niahere 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/agent/backends/claude.ts

@@ -1,4 +1,5 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { asError } from "../../utils/errors";
 import { randomUUID } from "crypto";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -126,7 +127,7 @@ class ClaudeSession implements AgentSession {
           res = await this.iterator!.next();
         } catch (err) {
           if (this.aborted) throw new Error(this.aborted);
-          throw err instanceof Error ? err : new Error(String(err));
+          throw asError(err);
         }
         if (this.aborted) throw new Error(this.aborted);
         if (res.done) {

package/src/agent/backends/codex.ts

@@ -7,6 +7,7 @@ import type { McpSourceContext } from "../../mcp";
 import { CodexNormalizer } from "./codex-normalize";
 import { mintRun, revokeRun } from "../mcp-endpoint";
 import { scopeOf, parseFailure } from "../failure";
+import { ignore } from "../../utils/errors";
 
 /**
  * Resolve the codex binary's absolute path. The daemon runs under launchd with a
@@ -256,7 +257,7 @@ class CodexSession implements AgentSession {
         };
       }
     } finally {
-      await stdout.cancel().catch(() => {});
+      await ignore(stdout.cancel(), "cancel codex stdout reader");
       revokeRun(token);
       this.proc = null;
     }

package/src/agent/mcp-endpoint.ts

@@ -4,6 +4,7 @@ import { randomBytes, randomUUID } from "crypto";
 import type { NiaTool } from "../mcp/tools/types";
 import type { McpSourceContext } from "../mcp";
 import { log } from "../utils/log";
+import { ignore } from "../utils/errors";
 import { gateSideEffects } from "../mcp/gate";
 
 /**
@@ -93,8 +94,8 @@ export function revokeRun(token: string): void {
   const entry = runs.get(token);
   if (!entry) return;
   runs.delete(token);
-  entry.transport.close().catch(() => {});
-  entry.server.close().catch(() => {});
+  void ignore(entry.transport.close(), "close run transport");
+  void ignore(entry.server.close(), "close run server");
 }
 
 /** Test/diagnostic: number of live runs. */

package/src/channels/common/chat-session.ts

@@ -54,3 +54,63 @@ export async function rotateRoom(
 export function chainLock(state: ChatState, fn: () => Promise<void>): void {
   state.lock = state.lock.then(fn, fn);
 }
+
+/** Seam so the registry is testable without a database. */
+export interface SessionOpener {
+  open(prefix: string, build: EngineFactory): Promise<ChatState>;
+  rotate(prefix: string, prev: ChatState | undefined, build: EngineFactory): Promise<ChatState>;
+}
+
+const defaultOpener: SessionOpener = { open: openChatEngine, rotate: rotateRoom };
+
+/**
+ * A channel's per-sender chat sessions. Every message-driven channel keeps one
+ * of these keyed by sender, and they all want the same four things: open on
+ * first use, reuse after, rotate on `/reset`, close everything on shutdown.
+ */
+export class ChatSessions<K> {
+  private readonly states = new Map<K, ChatState>();
+
+  constructor(
+    private readonly prefixFor: (key: K) => string,
+    private readonly build: EngineFactory,
+    private readonly opener: SessionOpener = defaultOpener,
+  ) {}
+
+  /** `build` overrides the default options for this call — Slack needs it to
+   *  thread watch behavior and thread context into a newly opened engine. */
+  async get(key: K, build: EngineFactory = this.build): Promise<ChatState> {
+    const existing = this.states.get(key);
+    if (existing) return existing;
+    const state = await this.opener.open(this.prefixFor(key), build);
+    this.states.set(key, state);
+    return state;
+  }
+
+  /** Start a fresh room for this sender, closing the previous one. */
+  async rotate(key: K, build: EngineFactory = this.build): Promise<ChatState> {
+    const state = await this.opener.rotate(this.prefixFor(key), this.states.get(key), build);
+    this.states.set(key, state);
+    return state;
+  }
+
+  /** The cached session, without opening one. */
+  peek(key: K): ChatState | undefined {
+    return this.states.get(key);
+  }
+
+  /** Whether a session is already open — Slack uses it to tell a live thread
+   *  from one it should ignore. */
+  has(key: K): boolean {
+    return this.states.has(key);
+  }
+
+  keys(): Iterable<K> {
+    return this.states.keys();
+  }
+
+  closeAll(): void {
+    for (const state of this.states.values()) state.engine.close();
+    this.states.clear();
+  }
+}

package/src/channels/phone/consult.ts

@@ -6,6 +6,7 @@
  * Heavyweight (multi-second latency) by design — keep usage selective.
  */
 import Anthropic from "@anthropic-ai/sdk";
+import { errMsg } from "../../utils/errors";
 import { loadIdentity } from "../../chat/identity";
 import { log } from "../../utils/log";
 
@@ -38,6 +39,6 @@ export async function consultClaude(question: string, callerLabel: string): Prom
     return "(no answer)";
   } catch (err) {
     log.error({ err }, "phone: consult_claude failed");
-    return `error consulting Claude: ${err instanceof Error ? err.message : String(err)}`;
+    return `error consulting Claude: ${errMsg(err)}`;
   }
 }

package/src/channels/phone/index.ts

@@ -25,6 +25,7 @@ import type { ServerWebSocket } from "bun";
 import type { Channel, Outbound, PhoneConfig, TwilioConfig } from "../../types";
 import { getConfig } from "../../utils/config";
 import { log } from "../../utils/log";
+import { ignore } from "../../utils/errors";
 import { getChannel } from "../registry";
 import { Session, Message } from "../../db/models";
 import { runMigrations } from "../../db/migrate";
@@ -194,9 +195,10 @@ class PhoneChannel implements Channel {
 
     if (!allowed) {
       log.warn({ from, callSid }, "phone: rejecting unauthorized caller");
-      getChannel("telegram")
-        ?.deliver({ text: `Phone: rejected call from ${from} (CallSid ${callSid})` })
-        .catch(() => {});
+      const notice = getChannel("telegram")?.deliver({
+        text: `Phone: rejected call from ${from} (CallSid ${callSid})`,
+      });
+      if (notice) void ignore(notice, "notify rejected caller");
       return twimlResponse(sayAndHangupTwiML("Sorry, this line is not currently accepting calls. Goodbye."));
     }
 

package/src/channels/phone/relay.ts

@@ -12,6 +12,7 @@
  *   const result = await relay.completion;
  */
 import { log } from "../../utils/log";
+import { errMsg } from "../../utils/errors";
 
 export interface PhoneToolDefinition {
   name: string;
@@ -57,6 +58,17 @@ export interface RelayOpts {
   model: string;
   voice: string;
   context: CallContext;
+  /** Injectable so the bridge is testable without dialing OpenAI. */
+  openAiWsFactory?: (url: string, key: string) => OpenAiSocket;
+}
+
+/** The slice of the realtime socket the relay drives. */
+export interface OpenAiSocket extends WebSocketLike {
+  addEventListener(type: string, listener: (ev: any) => void): void;
+}
+
+function connectOpenAi(url: string, key: string): OpenAiSocket {
+  return new WebSocket(url, { headers: { Authorization: `Bearer ${key}` } } as any) as unknown as OpenAiSocket;
 }
 
 export interface WebSocketLike {
@@ -76,7 +88,7 @@ export interface RelayHandle {
 }
 
 export function createRelay(opts: RelayOpts): RelayHandle {
-  const { twilioWs, openAiKey, model, voice, context } = opts;
+  const { twilioWs, openAiKey, model, voice, context, openAiWsFactory = connectOpenAi } = opts;
   const transcript: TranscriptTurn[] = [];
   let endedReason: RelayEndReason = "twilio_stop";
   let errorMsg: string | undefined;
@@ -84,9 +96,7 @@ export function createRelay(opts: RelayOpts): RelayHandle {
   let pendingAssistantText = "";
 
   const openAiUrl = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(model)}`;
-  const openAiWs = new WebSocket(openAiUrl, {
-    headers: { Authorization: `Bearer ${openAiKey}` },
-  } as any);
+  const openAiWs = openAiWsFactory(openAiUrl, openAiKey);
 
   /** Whether a response is currently in flight on the OpenAI side. */
   let responseActive = false;
@@ -268,7 +278,7 @@ export function createRelay(opts: RelayOpts): RelayHandle {
           try {
             output = await tool.handler(args);
           } catch (err) {
-            output = `error: ${err instanceof Error ? err.message : String(err)}`;
+            output = `error: ${errMsg(err)}`;
             log.error({ err, callSid: context.callSid, toolName }, "phone tool handler failed");
           }
         }

package/src/channels/slack.ts

@@ -5,11 +5,14 @@ import { relativeTime } from "../utils/format";
 import { runMigrations } from "../db/migrate";
 import { Session, Message } from "../db/models";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { getMcpServers } from "../mcp";
-import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { ChatSessions, chainLock } from "./common/chat-session";
 import { SlackAttachmentCache } from "./slack/attachments";
 import { SlackWatchReloader } from "./slack/watch";
 
+const logActivity = (status: string) => log.debug({ status }, "slack engine activity");
+
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
 function cleanSentinel(text: string): string {
   return text.replace(/`/g, "").trim();
@@ -75,7 +78,7 @@ class SlackChannel implements Channel {
 
     this.dmUserId = config.channels.slack.dm_user_id;
 
-    const chats = new Map<string, ChatState>();
+    const chats = new ChatSessions<string>(roomPrefix, buildEngineOpts());
     const channelNames = new Map<string, string>();
 
     async function resolveChannelName(app: App, channelId: string): Promise<string> {
@@ -111,30 +114,20 @@ class SlackChannel implements Channel {
       });
     }
 
-    async function getState(
+    const getState = (
       key: string,
       watchBehavior?: { channel: string; behavior: string },
       slackCtx?: SlackContext,
-    ): Promise<ChatState> {
-      let state = chats.get(key);
-      if (state) return state;
-      state = await openChatEngine(roomPrefix(key), buildEngineOpts(watchBehavior, slackCtx));
-      chats.set(key, state);
-      return state;
-    }
+    ): Promise<ChatState> => chats.get(key, buildEngineOpts(watchBehavior, slackCtx));
 
-    async function restartChat(
+    const restartChat = (
       key: string,
       watchBehavior?: { channel: string; behavior: string },
       slackCtx?: SlackContext,
-    ): Promise<ChatState> {
-      const state = await rotateRoom(roomPrefix(key), chats.get(key), buildEngineOpts(watchBehavior, slackCtx));
-      chats.set(key, state);
-      return state;
-    }
+    ): Promise<ChatState> => chats.rotate(key, buildEngineOpts(watchBehavior, slackCtx));
 
     function withLock(key: string, fn: () => Promise<void>): void {
-      const state = chats.get(key);
+      const state = chats.peek(key);
       if (!state) {
         fn().catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
         return;
@@ -177,13 +170,11 @@ class SlackChannel implements Channel {
         withLock(key, async () => {
           try {
             const { result } = await state.engine.send(subcommand, {
-              onActivity(status) {
-                log.debug({ status }, "slack engine activity");
-              },
+              onActivity: logActivity,
             });
             await respond(result.trim() || "(no response)");
           } catch (err) {
-            const errText = err instanceof Error ? err.message : String(err);
+            const errText = errMsg(err);
             await respond(`[error] ${errText}`);
           }
         });
@@ -437,9 +428,7 @@ class SlackChannel implements Channel {
           const { result, messageId, signal } = await state.engine.send(
             text,
             {
-              onActivity(status) {
-                log.debug({ status }, "slack engine activity");
-              },
+              onActivity: logActivity,
             },
             attachments,
           );
@@ -448,7 +437,7 @@ class SlackChannel implements Channel {
             await reactToSlackMessage(client, msg.channel, msg.ts, "skull").catch((err) =>
               log.debug({ err, channel: msg.channel }, "slack: failed to add provider-down reaction"),
             );
-            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             log.info({ channel: msg.channel, key, reaction: "skull" }, "slack provider failure sent as reaction");
             return;
           }
@@ -468,7 +457,7 @@ class SlackChannel implements Channel {
                 "slack: [NO_REPLY] sentinel mixed with content; suppressing send",
               );
             }
-            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             return;
           }
 
@@ -482,26 +471,27 @@ class SlackChannel implements Channel {
             } else {
               await say(reply);
             }
-            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
             log.info({ channel: msg.channel, key, chars: reply.length }, "slack reply sent");
           } catch (sendErr) {
-            if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+            if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
             throw sendErr;
           }
         } catch (err) {
-          const errText = err instanceof Error ? err.message : String(err);
+          const errText = errMsg(err);
           log.error({ err, channel: msg.channel }, "slack message processing failed");
 
           if (replyThreadTs) {
-            await client.chat
-              .postMessage({
+            await ignore(
+              client.chat.postMessage({
                 channel: msg.channel,
                 text: `[error] ${errText}`,
                 thread_ts: replyThreadTs,
-              })
-              .catch(() => {});
+              }),
+              "reply engine error in thread",
+            );
           } else {
-            await say(`[error] ${errText}`).catch(() => {});
+            await ignore(say(`[error] ${errText}`), "reply engine error");
           }
         } finally {
           await client.reactions

package/src/channels/sms.ts

@@ -16,25 +16,29 @@
  */
 import { getMcpServers } from "../mcp";
 import { runMigrations } from "../db/migrate";
-import type { Channel, ChatState, Outbound, TwilioConfig } from "../types";
+import type { Channel, Outbound, TwilioConfig } from "../types";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
-import { chainLock, openChatEngine } from "./common/chat-session";
-
-const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
+import { ChatSessions, chainLock } from "./common/chat-session";
+import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 
 class SmsChannel implements Channel {
   name = "sms" as const;
   private readonly twilio: TwilioConfig;
   /** Cached resolved "from" number: sms.from_number || phone.from_number */
   private readonly fromNumber: string;
-  private readonly chats = new Map<string, ChatState>();
+  private readonly chats: ChatSessions<string>;
 
   constructor(twilio: TwilioConfig, fromNumber: string) {
     this.twilio = twilio;
     this.fromNumber = fromNumber;
+    this.chats = new ChatSessions((remote) => `sms-${remote}`, () => ({
+      channel: "sms",
+      mcpServers: getMcpServers(),
+    }));
   }
 
   async start(): Promise<void> {
@@ -70,8 +74,7 @@ class SmsChannel implements Channel {
   }
 
   async stop(): Promise<void> {
-    for (const state of this.chats.values()) state.engine.close();
-    this.chats.clear();
+    this.chats.closeAll();
   }
 
   /** Outbound — used by send_message MCP tool. SMS is text-only; media is dropped with a warning. */
@@ -92,12 +95,12 @@ class SmsChannel implements Channel {
     const from = params.From || "";
     const body = params.Body || "";
 
-    if (!this.isAllowed(from)) {
+    if (!isAllowedSender(this.twilio, from)) {
       log.warn({ from }, "sms: rejecting non-allowlisted sender");
-      return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+      return ackTwiml();
     }
 
-    const state = await this.getState(from);
+    const state = await this.chats.get(from);
     // Ack the webhook immediately; reply via REST asynchronously to avoid
     // Twilio's ~15s webhook timeout when the engine takes longer.
     chainLock(state, async () => {
@@ -107,24 +110,15 @@ class SmsChannel implements Channel {
         await this.sendTo(from, reply);
       } catch (err) {
         log.error({ err, from }, "sms: engine error");
-        await this.sendTo(from, `[error] ${err instanceof Error ? err.message : String(err)}`).catch(() => {});
+        await ignore(this.sendTo(from, `[error] ${errMsg(err)}`), "reply engine error");
       }
     });
 
-    return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+    return ackTwiml();
   }
 
   private handleStatus(params: Record<string, string>): Response {
-    log.info(
-      {
-        messageSid: params.MessageSid,
-        status: params.MessageStatus,
-        errorCode: params.ErrorCode,
-        to: params.To,
-      },
-      "sms: delivery status",
-    );
-    return new Response("", { status: 204 });
+    return deliveryStatusAck("sms", params);
   }
 
   // --- Outbound ---
@@ -153,20 +147,6 @@ class SmsChannel implements Channel {
     }
   }
 
-  // --- Helpers ---
-
-  private isAllowed(remoteE164: string): boolean {
-    if (this.twilio.owner_number && remoteE164 === this.twilio.owner_number) return true;
-    return this.twilio.allowlist.includes(remoteE164);
-  }
-
-  private async getState(remoteE164: string): Promise<ChatState> {
-    let state = this.chats.get(remoteE164);
-    if (state) return state;
-    state = await openChatEngine(`sms-${remoteE164}`, () => ({ channel: "sms", mcpServers: getMcpServers() }));
-    this.chats.set(remoteE164, state);
-    return state;
-  }
 }
 
 export function createSmsChannel(): SmsChannel | null {

package/src/channels/telegram.ts

@@ -7,10 +7,11 @@ import { getConfig, updateRawConfig } from "../utils/config";
 import { runMigrations } from "../db/migrate";
 import { Message } from "../db/models";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 import { getNiaHome } from "../utils/paths";
-import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { ChatSessions, chainLock } from "./common/chat-session";
 
 function safeExtension(filename?: string): string {
   const ext = filename?.split(".").pop();
@@ -27,7 +28,10 @@ class TelegramChannel implements Channel {
   private bot: Bot | null = null;
   private outboundChatId: number | null = null;
   private isOpen = false;
-  private readonly chats = new Map<number, ChatState>();
+  private readonly chats = new ChatSessions<number>(
+    (chatId) => this.keyOf(chatId),
+    () => ({ channel: "telegram", mcpServers: getMcpServers() }),
+  );
 
   async start(): Promise<void> {
     const config = getConfig();
@@ -51,6 +55,7 @@ class TelegramChannel implements Channel {
   }
 
   async stop(): Promise<void> {
+    this.chats.closeAll();
     if (this.bot) {
       this.bot.stop();
       this.bot = null;
@@ -82,14 +87,14 @@ class TelegramChannel implements Channel {
   private async handleStart(ctx: Context): Promise<void> {
     if (!ctx.chatId || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     this.withLock(ctx.chatId, () => this.processMessage(ctx, state, "hi"));
   }
 
   private async handleRestart(ctx: Context): Promise<void> {
     if (!ctx.chatId || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.restartChat(ctx.chatId);
+    const state = await this.chats.rotate(ctx.chatId);
     log.info({ chatId: ctx.chatId, room: `tg-${ctx.chatId}-${state.roomIndex}` }, "new telegram conversation");
     await ctx.reply("New conversation started.");
   }
@@ -97,7 +102,7 @@ class TelegramChannel implements Channel {
   private async handleText(ctx: Context): Promise<void> {
     if (!ctx.chatId || !ctx.message?.text || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     const text = ctx.message.text;
     this.withLock(ctx.chatId, () => this.processMessage(ctx, state, text));
   }
@@ -105,7 +110,7 @@ class TelegramChannel implements Channel {
   private async handlePhoto(ctx: Context): Promise<void> {
     if (!ctx.chatId || !ctx.message?.photo || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     const chatId = ctx.chatId;
     this.withLock(chatId, async () => {
       try {
@@ -118,7 +123,7 @@ class TelegramChannel implements Channel {
         await this.processMessage(ctx, state, caption, [attachment]);
       } catch (err) {
         log.error({ err, chatId }, "failed to process photo");
-        await ctx.reply("Failed to process image.").catch(() => {});
+        await ignore(ctx.reply("Failed to process image."), "reply image failure");
       }
     });
   }
@@ -126,7 +131,7 @@ class TelegramChannel implements Channel {
   private async handleDocument(ctx: Context): Promise<void> {
     if (!ctx.chatId || !ctx.message?.document || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     const chatId = ctx.chatId;
     this.withLock(chatId, async () => {
       try {
@@ -157,7 +162,7 @@ class TelegramChannel implements Channel {
         await this.processMessage(ctx, state, caption, [attachment]);
       } catch (err) {
         log.error({ err, chatId }, "failed to process document");
-        await ctx.reply("Failed to process document.").catch(() => {});
+        await ignore(ctx.reply("Failed to process document."), "reply document failure");
       }
     });
   }
@@ -176,25 +181,25 @@ class TelegramChannel implements Channel {
     log.info({ chatId, text: text.slice(0, 100), attachments: attachments?.length || 0 }, "telegram message received");
 
     const typingInterval = setInterval(() => {
-      bot.api.sendChatAction(chatId, "typing").catch(() => {});
+      void ignore(bot.api.sendChatAction(chatId, "typing"), "send typing indicator");
     }, 4000);
-    bot.api.sendChatAction(chatId, "typing").catch(() => {});
+    void ignore(bot.api.sendChatAction(chatId, "typing"), "send typing indicator");
 
     try {
       const { result, messageId } = await state.engine.send(text, {}, attachments);
       const reply = result.trim() || "(no response)";
       try {
         await bot.api.sendMessage(chatId, reply);
-        if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+        if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
         log.info({ chatId, chars: result.length }, "telegram reply sent");
       } catch (sendErr) {
-        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
         throw sendErr;
       }
     } catch (err) {
-      const errText = err instanceof Error ? err.message : String(err);
+      const errText = errMsg(err);
       log.error({ err, chatId }, "telegram message processing failed");
-      await bot.api.sendMessage(chatId, `[error] ${errText}`).catch(() => {});
+      await ignore(bot.api.sendMessage(chatId, `[error] ${errText}`), "reply engine error");
     } finally {
       clearInterval(typingInterval);
     }
@@ -202,25 +207,8 @@ class TelegramChannel implements Channel {
 
   // --- Session / state helpers ---
 
-  private async getState(chatId: number): Promise<ChatState> {
-    let state = this.chats.get(chatId);
-    if (state) return state;
-    state = await openChatEngine(this.keyOf(chatId), () => ({ channel: "telegram", mcpServers: getMcpServers() }));
-    this.chats.set(chatId, state);
-    return state;
-  }
-
-  private async restartChat(chatId: number): Promise<ChatState> {
-    const state = await rotateRoom(this.keyOf(chatId), this.chats.get(chatId), () => ({
-      channel: "telegram",
-      mcpServers: getMcpServers(),
-    }));
-    this.chats.set(chatId, state);
-    return state;
-  }
-
   private withLock(chatId: number, fn: () => Promise<void>): void {
-    const state = this.chats.get(chatId);
+    const state = this.chats.peek(chatId);
     if (!state) {
       fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
       return;
@@ -238,7 +226,7 @@ class TelegramChannel implements Channel {
   private gate(ctx: Context): boolean {
     if (!ctx.chatId) return false;
     if (this.isAllowed(ctx.chatId)) return true;
-    ctx.reply("Unauthorized.").catch(() => {});
+    void ignore(ctx.reply("Unauthorized."), "reply unauthorized");
     return false;
   }
 

package/src/channels/twilio/media-cache.ts

@@ -16,6 +16,7 @@ import { createHash } from "crypto";
 import { join } from "path";
 import { getNiaHome } from "../../utils/paths";
 import { log } from "../../utils/log";
+import { ignore } from "../../utils/errors";
 
 const MAX_FILES = 100;
 const MAX_BYTES = 10 * 1024 * 1024;
@@ -85,7 +86,7 @@ async function evict(): Promise<void> {
   let alive: typeof stats = [];
   for (const s of stats) {
     if (now - s.mtime > MAX_AGE_MS) {
-      await unlink(s.path).catch(() => {});
+      await ignore(unlink(s.path), "prune cached media");
     } else {
       alive.push(s);
     }
@@ -95,13 +96,13 @@ async function evict(): Promise<void> {
 
   while (alive.length > MAX_FILES) {
     const victim = alive.shift()!;
-    await unlink(victim.path).catch(() => {});
+    await ignore(unlink(victim.path), "prune cached media");
   }
 
   let totalBytes = alive.reduce((sum, f) => sum + f.size, 0);
   while (totalBytes > MAX_BYTES && alive.length > 0) {
     const victim = alive.shift()!;
     totalBytes -= victim.size;
-    await unlink(victim.path).catch(() => {});
+    await ignore(unlink(victim.path), "prune cached media");
   }
 }