niahere 0.3.1 → 0.3.2

package/package.json

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

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

@@ -0,0 +1,56 @@
+/**
+ * Shared chat-engine lifecycle helpers used by the message-driven
+ * channels (telegram, slack, sms, whatsapp). Each channel keeps its
+ * own `Map<senderKey, ChatState>`; these helpers cover the bits that
+ * were copy-pasted between them:
+ *
+ *   - resolve the latest room index for a prefix and open a fresh engine
+ *   - rotate to a new room (for `/reset` / `/new` / `/restart`), persisting
+ *     a placeholder session so the new index survives daemon restarts
+ *   - chain work onto a per-sender lock so messages from the same sender
+ *     don't race
+ *
+ * The caller supplies a builder lambda for the EngineOptions so channels
+ * that need room-aware fields (e.g. Slack's per-room `mcpServers`) can
+ * compute them with the resolved room name. Channels with static options
+ * just ignore the `room` argument in their builder.
+ */
+import { createChatEngine } from "../../chat/engine";
+import { Session } from "../../db/models";
+import { log } from "../../utils/log";
+import type { ChatState } from "../../types";
+import type { EngineOptions } from "../../types/engine";
+
+type EngineFactory = (room: string) => Omit<EngineOptions, "room" | "resume">;
+
+/** Open (or resume) a chat engine for `prefix`. The resulting ChatState is the caller's to cache. */
+export async function openChatEngine(prefix: string, buildOpts: EngineFactory): Promise<ChatState> {
+  const roomIndex = await Session.getLatestRoomIndex(prefix);
+  const room = `${prefix}-${roomIndex}`;
+  const opts = buildOpts(room);
+  log.info({ channel: opts.channel, room }, "chat-session: opening engine");
+  const engine = await createChatEngine({ ...opts, room, resume: true });
+  return { engine, roomIndex, lock: Promise.resolve() };
+}
+
+/** Rotate to a fresh room. Closes `prev` if supplied, persists a placeholder Session so the index survives restarts. */
+export async function rotateRoom(
+  prefix: string,
+  prev: ChatState | undefined,
+  buildOpts: EngineFactory,
+): Promise<ChatState> {
+  if (prev) prev.engine.close();
+  const prevIdx = await Session.getLatestRoomIndex(prefix);
+  const roomIndex = prevIdx + 1;
+  const room = `${prefix}-${roomIndex}`;
+  await Session.create(`placeholder-${room}`, room);
+  const opts = buildOpts(room);
+  log.info({ channel: opts.channel, room }, "chat-session: rotated room");
+  const engine = await createChatEngine({ ...opts, room, resume: false });
+  return { engine, roomIndex, lock: Promise.resolve() };
+}
+
+/** Serialize `fn` onto `state.lock`. Both success and failure forward so a thrown error doesn't poison the chain. */
+export function chainLock(state: ChatState, fn: () => Promise<void>): void {
+  state.lock = state.lock.then(fn, fn);
+}

package/src/channels/phone/index.ts

@@ -22,7 +22,7 @@
  *   - consult.ts           — escape hatch to Claude for memory-aware reasoning
  */
 import type { ServerWebSocket } from "bun";
-import type { Channel, PhoneConfig, TwilioConfig } from "../../types";
+import type { Channel, Outbound, PhoneConfig, TwilioConfig } from "../../types";
 import { getConfig } from "../../utils/config";
 import { log } from "../../utils/log";
 import { getChannel } from "../registry";
@@ -66,7 +66,7 @@ const HARD_MAX_MINUTES = 30;
 const WS_PATH = "/twilio/voice/stream";
 
 class PhoneChannel implements Channel {
-  name = "phone";
+  name = "phone" as const;
   private readonly phone: PhoneConfig;
   private readonly twilio: TwilioConfig;
   private readonly pending = new Map<string, PendingCall>();
@@ -92,7 +92,7 @@ class PhoneChannel implements Channel {
 
     server.registerHttp("/twilio/voice/incoming", (req, ctx) => this.handleIncoming(req, ctx.params));
     server.registerHttp("/twilio/voice/outbound", (req, ctx) => this.handleOutboundTwiml(req, ctx.params));
-    server.registerHttp("/twilio/voice/status", (req, ctx) => this.handleStatus(ctx.params), {
+    server.registerHttp("/twilio/voice/status", (_req, ctx) => this.handleStatus(ctx.params), {
       dedupOn: "CallSid",
     });
 
@@ -127,6 +127,15 @@ class PhoneChannel implements Channel {
     // it running here would block SMS/WhatsApp if they're also bound to it.
   }
 
+  /**
+   * Phone is voice-only — agent-initiated text/media doesn't have a sensible
+   * delivery shape over Twilio Voice. Callers that want a text notification
+   * about a call should target a text channel (telegram, slack, whatsapp).
+   */
+  async deliver(_out: Outbound): Promise<void> {
+    throw new Error("phone: text/media delivery is not supported — use a text channel or placeCall() for voice");
+  }
+
   // --- Outbound entrypoint (used by the place_call MCP tool and CLI test) ---
 
   async placeCall(opts: {
@@ -186,7 +195,7 @@ class PhoneChannel implements Channel {
     if (!allowed) {
       log.warn({ from, callSid }, "phone: rejecting unauthorized caller");
       getChannel("telegram")
-        ?.sendMessage?.(`Phone: rejected call from ${from} (CallSid ${callSid})`)
+        ?.deliver({ text: `Phone: rejected call from ${from} (CallSid ${callSid})` })
         .catch(() => {});
       return twimlResponse(sayAndHangupTwiML("Sorry, this line is not currently accepting calls. Goodbye."));
     }

package/src/channels/phone/tools.ts

@@ -47,8 +47,8 @@ export function buildPhoneTools(ctx: ToolContextOpts): PhoneToolDefinition[] {
       handler: async (args) => {
         const text = String(args.text || "").slice(0, 1000);
         const tg = getChannel("telegram");
-        if (!tg || !tg.sendMessage) return "telegram unavailable";
-        await tg.sendMessage(`[Phone] ${text}`);
+        if (!tg) return "telegram unavailable";
+        await tg.deliver({ text: `[Phone] ${text}` });
         return "sent";
       },
     },

package/src/channels/slack.ts

@@ -2,8 +2,7 @@ import { App } from "@slack/bolt";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
-import { createChatEngine } from "../chat/engine";
-import type { Channel, ChatState, Attachment, AttachmentType } from "../types";
+import type { Channel, ChatState, Attachment, AttachmentType, Outbound, Recipient } from "../types";
 import { getConfig, updateRawConfig, resetConfig } from "../utils/config";
 import { relativeTime } from "../utils/format";
 import { runMigrations } from "../db/migrate";
@@ -13,6 +12,7 @@ import { getMcpServers } from "../mcp";
 import { getNiaHome, getPaths } from "../utils/paths";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 import { resolveWatchBehavior } from "../utils/watches";
+import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
 
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
 function cleanSentinel(text: string): string {
@@ -20,47 +20,39 @@ function cleanSentinel(text: string): string {
 }
 
 class SlackChannel implements Channel {
-  name = "slack";
+  name = "slack" as const;
   private app: App | null = null;
   private dmUserId: string | null = null;
   /** Timestamps of messages Nia posted proactively (used to detect replies to our own messages) */
   private outboundTs = new Set<string>();
 
-  async sendMessage(text: string): Promise<void> {
+  async deliver(out: Outbound): Promise<void> {
     if (!this.app) throw new Error("Slack not started");
-    const target = this.dmUserId;
-    if (!target) throw new Error("No Slack recipient — set dm_user_id in config");
-    const result = await this.app.client.chat.postMessage({ channel: target, text });
-    if (result.ts) this.outboundTs.add(result.ts);
-  }
+    const dest = this.resolveDest(out.to);
+
+    if (out.media) {
+      const buffer = Buffer.from(out.media.data);
+      const filename = out.media.filename || `file.${out.media.mimeType.split("/")[1] || "bin"}`;
+      await this.app.client.filesUploadV2({
+        channel_id: dest.channel,
+        file: buffer,
+        filename,
+        ...(dest.threadTs ? { thread_ts: dest.threadTs } : {}),
+      } as any);
+    }
 
-  async sendToThread(channelId: string, text: string, threadTs?: string): Promise<void> {
-    if (!this.app) throw new Error("Slack not started");
-    const opts: Record<string, unknown> = { channel: channelId, text };
-    if (threadTs) opts.thread_ts = threadTs;
-    const result = await this.app.client.chat.postMessage(opts as any);
-    if (result.ts) this.outboundTs.add(result.ts);
+    if (out.text) {
+      const opts: Record<string, unknown> = { channel: dest.channel, text: out.text };
+      if (dest.threadTs) opts.thread_ts = dest.threadTs;
+      const result = await this.app.client.chat.postMessage(opts as any);
+      if (result.ts) this.outboundTs.add(result.ts);
+    }
   }
 
-  async sendMedia(data: Buffer, mimeType: string, filename?: string): Promise<void> {
-    if (!this.app) throw new Error("Slack not started");
-    const target = this.dmUserId;
-    if (!target) throw new Error("No Slack recipient — set dm_user_id in config");
-    await this.app.client.filesUploadV2({
-      channel_id: target,
-      file: data,
-      filename: filename || `file.${mimeType.split("/")[1] || "bin"}`,
-    });
-  }
-
-  async sendMediaToThread(channelId: string, data: Buffer, mimeType: string, filename?: string, threadTs?: string): Promise<void> {
-    if (!this.app) throw new Error("Slack not started");
-    await this.app.client.filesUploadV2({
-      channel_id: channelId,
-      file: data,
-      filename: filename || `file.${mimeType.split("/")[1] || "bin"}`,
-      ...(threadTs ? { thread_ts: threadTs } : {}),
-    } as any);
+  private resolveDest(to: Recipient | undefined): { channel: string; threadTs?: string } {
+    if (to?.kind === "thread") return { channel: to.channelId, threadTs: to.threadTs };
+    if (!this.dmUserId) throw new Error("No Slack recipient — set dm_user_id in config");
+    return { channel: this.dmUserId };
   }
 
   async start(): Promise<void> {
@@ -87,62 +79,46 @@ class SlackChannel implements Channel {
       return name;
     }
 
-    function roomPrefix(key: string): string {
-      return `slack-${key}`;
-    }
-
-    function roomName(key: string, index: number): string {
-      return `slack-${key}-${index}`;
-    }
-
     interface SlackContext {
       slackChannelId?: string;
       slackThreadTs?: string;
     }
 
-    async function getState(key: string, watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext): Promise<ChatState> {
-      let state = chats.get(key);
-      if (!state) {
-        const prefix = roomPrefix(key);
-        const idx = await Session.getLatestRoomIndex(prefix);
-        const room = roomName(key, idx);
-        const engine = await createChatEngine({
-          room,
-          channel: "slack",
-          resume: true,
-          mcpServers: getMcpServers({ channel: "slack", room, ...slackCtx }),
-          watchBehavior,
-        });
-        state = { engine, roomIndex: idx, lock: Promise.resolve() };
-        chats.set(key, state);
-      }
-      return state;
+    function roomPrefix(k: string): string {
+      return `slack-${k}`;
     }
 
-    async function restartChat(key: string, watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext): Promise<ChatState> {
-      const old = chats.get(key);
-      if (old) old.engine.close();
-
-      const prefix = roomPrefix(key);
-      const prevIdx = await Session.getLatestRoomIndex(prefix);
-      const newIdx = prevIdx + 1;
-      const room = roomName(key, newIdx);
-
-      // Persist a placeholder session immediately so the room index survives
-      // daemon restarts (otherwise getState falls back to the old room).
-      await Session.create(`placeholder-${room}`, room);
+    function roomName(k: string, index: number): string {
+      return `slack-${k}-${index}`;
+    }
 
-      log.info({ key, room }, "slack: creating chat engine");
-      const engine = await createChatEngine({
-        room,
+    function buildEngineOpts(watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext) {
+      return (room: string) => ({
         channel: "slack",
-        resume: false,
         mcpServers: getMcpServers({ channel: "slack", room, ...slackCtx }),
         watchBehavior,
       });
-      const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
+    }
+
+    async function 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;
+    }
+
+    async function 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);
-      log.info({ key, room, activeSessions: chats.size }, "slack: engine ready");
       return state;
     }
 
@@ -152,9 +128,7 @@ class SlackChannel implements Channel {
         fn().catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
         return;
       }
-      const queued = state.lock !== Promise.resolve();
-      if (queued) log.debug({ key }, "slack: message queued behind active lock");
-      state.lock = state.lock.then(fn, fn).catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
+      chainLock(state, fn);
     }
 
     const self = this;
@@ -364,7 +338,7 @@ class SlackChannel implements Channel {
 
         try {
           const data = await downloadSlackFile(file.url_private_download);
-          const error = validateAttachment(data, mime);
+          const error = validateAttachment(data);
           if (error) {
             log.warn({ file: file.name, error }, "skipping slack attachment");
             continue;
@@ -383,7 +357,13 @@ class SlackChannel implements Channel {
           const entry: CachedFile = { path: diskPath, type: attType, mimeType: finalMime, filename: file.name };
           fileIndex.set(indexedKey, entry);
 
-          attachments.push({ type: attType, data: finalData, mimeType: finalMime, filename: file.name, sourcePath: diskPath });
+          attachments.push({
+            type: attType,
+            data: finalData,
+            mimeType: finalMime,
+            filename: file.name,
+            sourcePath: diskPath,
+          });
         } catch (err) {
           log.warn({ err, file: file.name }, "failed to download slack file");
         }

package/src/channels/sms.ts

@@ -14,29 +14,26 @@
  * variable deliverability under TRAI scrubbing rules. Test empirically;
  * if outbound fails, the inbound leg (Aman → Nia) is more reliable.
  */
-import { createChatEngine } from "../chat/engine";
 import { getMcpServers } from "../mcp";
-import { Session } from "../db/models";
 import { runMigrations } from "../db/migrate";
-import type { Channel, ChatState, PhoneConfig, SmsConfig, TwilioConfig } from "../types";
+import type { Channel, ChatState, Outbound, TwilioConfig } from "../types";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
 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>';
 
 class SmsChannel implements Channel {
-  name = "sms";
+  name = "sms" as const;
   private readonly twilio: TwilioConfig;
-  private readonly sms: SmsConfig;
   /** Cached resolved "from" number: sms.from_number || phone.from_number */
   private readonly fromNumber: string;
   private readonly chats = new Map<string, ChatState>();
 
-  constructor(twilio: TwilioConfig, sms: SmsConfig, fromNumber: string) {
+  constructor(twilio: TwilioConfig, fromNumber: string) {
     this.twilio = twilio;
-    this.sms = sms;
     this.fromNumber = fromNumber;
   }
 
@@ -77,10 +74,16 @@ class SmsChannel implements Channel {
     this.chats.clear();
   }
 
-  /** Outbound to the owner — used by send_message MCP tool. */
-  async sendMessage(text: string): Promise<void> {
+  /** Outbound — used by send_message MCP tool. SMS is text-only; media is dropped with a warning. */
+  async deliver(out: Outbound): Promise<void> {
     if (!this.twilio.owner_number) throw new Error("sms: owner_number not set");
-    await this.sendTo(this.twilio.owner_number, text);
+    // SMS has no threading; recipient kind is ignored.
+    if (out.media) {
+      log.warn({ filename: out.media.filename }, "sms: media payload dropped (channel is text-only)");
+    }
+    if (out.text) {
+      await this.sendTo(this.twilio.owner_number, out.text);
+    }
   }
 
   // --- Inbound webhook ---
@@ -97,19 +100,16 @@ class SmsChannel implements Channel {
     const state = await this.getState(from);
     // Ack the webhook immediately; reply via REST asynchronously to avoid
     // Twilio's ~15s webhook timeout when the engine takes longer.
-    state.lock = state.lock.then(
-      async () => {
-        try {
-          const { result } = await state.engine.send(body);
-          const reply = result.trim() || "(no response)";
-          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(() => {});
-        }
-      },
-      (err) => log.error({ err, from }, "sms: lock chain error"),
-    );
+    chainLock(state, async () => {
+      try {
+        const { result } = await state.engine.send(body);
+        const reply = result.trim() || "(no response)";
+        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(() => {});
+      }
+    });
 
     return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
   }
@@ -160,17 +160,7 @@ class SmsChannel implements Channel {
   private async getState(remoteE164: string): Promise<ChatState> {
     let state = this.chats.get(remoteE164);
     if (state) return state;
-    const prefix = `sms-${remoteE164}`;
-    const idx = await Session.getLatestRoomIndex(prefix);
-    const room = `${prefix}-${idx}`;
-    log.info({ remoteE164, room }, "sms: creating chat engine");
-    const engine = await createChatEngine({
-      room,
-      channel: "sms",
-      resume: true,
-      mcpServers: getMcpServers(),
-    });
-    state = { engine, roomIndex: idx, lock: Promise.resolve() };
+    state = await openChatEngine(`sms-${remoteE164}`, () => ({ channel: "sms", mcpServers: getMcpServers() }));
     this.chats.set(remoteE164, state);
     return state;
   }
@@ -183,7 +173,7 @@ export function createSmsChannel(): SmsChannel | null {
   // sms.from_number falls back to phone.from_number (same number for voice + SMS).
   const fromNumber = sms.from_number ?? phone.from_number;
   if (!fromNumber) return null;
-  return new SmsChannel(twilio, sms, fromNumber);
+  return new SmsChannel(twilio, fromNumber);
 }
 
 export type { SmsChannel };

package/src/channels/telegram.ts

@@ -2,15 +2,15 @@ import { Bot, InputFile } from "grammy";
 import { createHash } from "crypto";
 import { mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
-import { createChatEngine } from "../chat/engine";
-import type { Channel, ChatState, Attachment } from "../types";
+import type { Channel, ChatState, Attachment, Outbound } from "../types";
 import { getConfig, updateRawConfig } from "../utils/config";
 import { runMigrations } from "../db/migrate";
-import { Session, Message } from "../db/models";
+import { Message } from "../db/models";
 import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 import { getNiaHome } from "../utils/paths";
+import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
 
 function safeExtension(filename?: string): string {
   const ext = filename?.split(".").pop();
@@ -23,27 +23,27 @@ function cacheExtension(filename: string | undefined, mimeType: string): string
 }
 
 class TelegramChannel implements Channel {
-  name = "telegram";
+  name = "telegram" as const;
   private bot: Bot | null = null;
   private outboundChatId: number | null = null;
 
-  async sendMessage(text: string): Promise<void> {
+  async deliver(out: Outbound): Promise<void> {
     if (!this.bot) throw new Error("Telegram not started");
     const chatId = this.outboundChatId;
     if (!chatId) throw new Error("No outbound chat ID registered");
-    await this.bot.api.sendMessage(chatId, text);
-  }
-
-  async sendMedia(data: Buffer, mimeType: string, filename?: string): Promise<void> {
-    if (!this.bot) throw new Error("Telegram not started");
-    const chatId = this.outboundChatId;
-    if (!chatId) throw new Error("No outbound chat ID registered");
-
-    const file = new InputFile(data, filename);
-    if (mimeType.startsWith("image/")) {
-      await this.bot.api.sendPhoto(chatId, file);
-    } else {
-      await this.bot.api.sendDocument(chatId, file);
+    // Telegram has no native threading; thread recipients fall back to the
+    // configured DM chat (the same place we'd send to for `owner`).
+
+    if (out.media) {
+      const file = new InputFile(Buffer.from(out.media.data), out.media.filename);
+      if (out.media.mimeType.startsWith("image/")) {
+        await this.bot.api.sendPhoto(chatId, file);
+      } else {
+        await this.bot.api.sendDocument(chatId, file);
+      }
+    }
+    if (out.text) {
+      await this.bot.api.sendMessage(chatId, out.text);
     }
   }
 
@@ -57,7 +57,13 @@ class TelegramChannel implements Channel {
     return Buffer.from(await resp.arrayBuffer());
   }
 
-  private cacheAttachment(chatId: number, roomIndex: number, data: Buffer, mimeType: string, filename?: string): string {
+  private cacheAttachment(
+    chatId: number,
+    roomIndex: number,
+    data: Buffer,
+    mimeType: string,
+    filename?: string,
+  ): string {
     const scope = `telegram-${chatId}-${roomIndex}`;
     const dir = join(getNiaHome(), "tmp", "attachments", scope);
     mkdirSync(dir, { recursive: true });
@@ -78,44 +84,23 @@ class TelegramChannel implements Channel {
 
     const chats = new Map<number, ChatState>();
 
-    function roomPrefix(chatId: number): string {
+    function keyOf(chatId: number): string {
       return `tg-${chatId}`;
     }
 
-    function roomName(chatId: number, index: number): string {
-      return `tg-${chatId}-${index}`;
-    }
-
     async function getState(chatId: number): Promise<ChatState> {
       let state = chats.get(chatId);
-      if (!state) {
-        const prefix = roomPrefix(chatId);
-        const idx = await Session.getLatestRoomIndex(prefix);
-        const room = roomName(chatId, idx);
-        log.info({ chatId, room }, "telegram: creating chat engine");
-        const engine = await createChatEngine({ room, channel: "telegram", resume: true, mcpServers: getMcpServers() });
-        state = { engine, roomIndex: idx, lock: Promise.resolve() };
-        chats.set(chatId, state);
-        log.info({ chatId, room, activeSessions: chats.size }, "telegram: engine ready");
-      }
+      if (state) return state;
+      state = await openChatEngine(keyOf(chatId), () => ({ channel: "telegram", mcpServers: getMcpServers() }));
+      chats.set(chatId, state);
       return state;
     }
 
     async function restartChat(chatId: number): Promise<ChatState> {
-      const old = chats.get(chatId);
-      if (old) old.engine.close();
-
-      const prefix = roomPrefix(chatId);
-      const prevIdx = await Session.getLatestRoomIndex(prefix);
-      const newIdx = prevIdx + 1;
-      const room = roomName(chatId, newIdx);
-
-      // Persist a placeholder session immediately so the room index survives
-      // daemon restarts (otherwise getState falls back to the old room).
-      await Session.create(`placeholder-${room}`, room);
-
-      const engine = await createChatEngine({ room, channel: "telegram", resume: false, mcpServers: getMcpServers() });
-      const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
+      const state = await rotateRoom(keyOf(chatId), chats.get(chatId), () => ({
+        channel: "telegram",
+        mcpServers: getMcpServers(),
+      }));
       chats.set(chatId, state);
       return state;
     }
@@ -126,9 +111,7 @@ class TelegramChannel implements Channel {
         fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
         return;
       }
-      const queued = state.lock !== Promise.resolve();
-      if (queued) log.debug({ chatId }, "telegram: message queued behind active lock");
-      state.lock = state.lock.then(fn, fn);
+      chainLock(state, fn);
     }
 
     const isOpen = config.channels.telegram.open;
@@ -151,7 +134,10 @@ class TelegramChannel implements Channel {
 
     async function processMessage(ctx: any, state: ChatState, text: string, attachments?: Attachment[]): Promise<void> {
       const chatId = ctx.chatId;
-      log.info({ chatId, text: text.slice(0, 100), attachments: attachments?.length || 0 }, "telegram message received");
+      log.info(
+        { chatId, text: text.slice(0, 100), attachments: attachments?.length || 0 },
+        "telegram message received",
+      );
 
       // Show typing indicator throughout
       const typingInterval = setInterval(() => {
@@ -251,7 +237,7 @@ class TelegramChannel implements Channel {
           const mime = doc.mime_type || "application/octet-stream";
           const attType = classifyMime(mime) || "file";
           let data = await self.downloadFile(doc.file_id);
-          const error = validateAttachment(data, mime);
+          const error = validateAttachment(data);
           if (error) {
             await ctx.reply(error);
             return;
@@ -263,7 +249,13 @@ class TelegramChannel implements Channel {
             finalMime = prepared.mimeType;
           }
           const sourcePath = self.cacheAttachment(ctx.chatId, state.roomIndex, data, finalMime, doc.file_name);
-          const attachment: Attachment = { type: attType, data, mimeType: finalMime, filename: doc.file_name, sourcePath };
+          const attachment: Attachment = {
+            type: attType,
+            data,
+            mimeType: finalMime,
+            filename: doc.file_name,
+            sourcePath,
+          };
           const caption = ctx.message.caption || (attType === "image" ? "What's in this image?" : "Here's a file.");
           await processMessage(ctx, state, caption, [attachment]);
         } catch (err) {