niahere 0.3.0 → 0.3.2

package/src/channels/phone/index.ts

@@ -1,8 +1,10 @@
 /**
  * Phone channel — voice calling via Twilio + OpenAI Realtime.
  *
- * Boots an HTTP+WebSocket server inside the daemon. Twilio reaches it
- * through a public tunnel (cloudflared in our setup). Two surfaces:
+ * Registers HTTP + WebSocket routes on the shared TwilioWebhookServer
+ * (which other Twilio channels — sms, whatsapp — also use). The server
+ * handles signature validation, dedup, and rate-limit middleware so this
+ * file only owns voice-specific logic:
  *
  *   - Inbound: caller dials our Twilio number; we return TwiML that opens
  *     a Media Stream back to us; the stream is bridged to OpenAI Realtime.
@@ -11,33 +13,30 @@
  *     with a per-call goal seeded into the realtime session.
  *
  * Submodules:
- *   - twilio.ts        — REST + webhook signature helpers
- *   - twiml.ts         — TwiML XML builders
- *   - relay.ts         — Twilio Media Stream <-> OpenAI Realtime bridge
- *   - instructions.ts  — system-prompt builders for inbound/outbound
- *   - tools.ts         — function-calling tools exposed to the realtime model
- *   - consult.ts       — escape hatch to Claude for memory-aware reasoning
+ *   - ../twilio/server.ts  — shared HTTP+WS server
+ *   - ../twilio/rest.ts    — Twilio REST API helpers (placeCall, etc.)
+ *   - twiml.ts             — TwiML XML builders
+ *   - relay.ts             — Twilio Media Stream <-> OpenAI Realtime bridge
+ *   - instructions.ts      — system-prompt builders for inbound/outbound
+ *   - tools.ts             — function-calling tools exposed to the realtime model
+ *   - consult.ts           — escape hatch to Claude for memory-aware reasoning
  */
-import type { Server, ServerWebSocket } from "bun";
-import type { Channel, PhoneConfig } from "../../types";
+import type { ServerWebSocket } from "bun";
+import type { Channel, Outbound, PhoneConfig, TwilioConfig } from "../../types";
 import { getConfig } from "../../utils/config";
 import { log } from "../../utils/log";
 import { getChannel } from "../registry";
 import { Session, Message } from "../../db/models";
 import { runMigrations } from "../../db/migrate";
 
-import { placeCall as twilioPlaceCall, validateTwilioSignature } from "./twilio";
+import { getTwilioServer, type WsConnectionData } from "../twilio/server";
+import { placeCall as twilioPlaceCall } from "../twilio/rest";
 import { streamTwiML, sayAndHangupTwiML, rejectTwiML } from "./twiml";
 import { createRelay, type CallContext, type RelayHandle, type RelayResult } from "./relay";
 import { buildInboundInstructions, buildOutboundInstructions } from "./instructions";
 import { buildPhoneTools } from "./tools";
 
-interface WsData {
-  streamSid: string | null;
-}
-
 interface PendingCall {
-  /** Context written when the call is initiated; consumed by the WS upgrade. */
   context: Omit<CallContext, "streamSid" | "tools">;
   startedAt: number;
 }
@@ -64,97 +63,77 @@ function defer<T>(): Deferred<T> {
 const DEFAULT_MAX_MINUTES = 10;
 const HARD_MAX_MINUTES = 30;
 
+const WS_PATH = "/twilio/voice/stream";
+
 class PhoneChannel implements Channel {
-  name = "phone";
-  private server: Server<WsData> | null = null;
-  private readonly cfg: PhoneConfig;
-  /** Calls placed/answered but whose Media Stream hasn't connected yet. */
+  name = "phone" as const;
+  private readonly phone: PhoneConfig;
+  private readonly twilio: TwilioConfig;
   private readonly pending = new Map<string, PendingCall>();
-  /** Active relays, keyed by streamSid (assigned on Twilio "start" event). */
+  /** Active relays keyed by streamSid. */
   private readonly active = new Map<string, ActiveCall>();
-  /** Per-callSid completion deferreds. Resolved when the call's transcript is persisted. */
+  /** Per-callSid completion deferreds; resolved after persistCall. */
   private readonly completions = new Map<string, Deferred<RelayResult>>();
 
-  constructor(cfg: PhoneConfig) {
-    this.cfg = cfg;
+  constructor(phone: PhoneConfig, twilio: TwilioConfig) {
+    this.phone = phone;
+    this.twilio = twilio;
   }
 
-  // --- Channel lifecycle ---
-
   async start(): Promise<void> {
     await runMigrations();
-    const self = this;
-
-    this.server = Bun.serve<WsData, never>({
-      port: this.cfg.port,
-      async fetch(req, server) {
-        const path = new URL(req.url).pathname;
-
-        if (path === "/healthz") return new Response("ok", { status: 200 });
-
-        if (path === "/twilio/voice/stream") {
-          const ok = server.upgrade(req, { data: { streamSid: null } });
-          return ok ? undefined : new Response("expected websocket", { status: 400 });
-        }
-        if (path === "/twilio/voice/incoming" && req.method === "POST") {
-          return await self.handleIncoming(req);
-        }
-        if (path === "/twilio/voice/outbound" && req.method === "POST") {
-          return await self.handleOutboundTwiml(req);
-        }
-        if (path === "/twilio/voice/status" && req.method === "POST") {
-          return await self.handleStatus(req);
-        }
-        return new Response("not found", { status: 404 });
-      },
-      websocket: {
-        message(ws, message) {
-          const data = typeof message === "string" ? message : new TextDecoder().decode(message);
-          const sid = ws.data.streamSid;
-          if (sid) {
-            const active = self.active.get(sid);
-            if (active) {
-              active.handle.onTwilioMessage(data);
-              return;
-            }
-          }
-          self.bootstrapWsMessage(ws, data).catch((err) => {
-            log.error({ err }, "phone: ws bootstrap failed");
-            try {
-              ws.close();
-            } catch {}
-          });
-        },
-        close(ws) {
-          const sid = ws.data.streamSid;
-          if (!sid) return;
-          const active = self.active.get(sid);
-          if (active) active.handle.onTwilioClose();
-        },
-      },
+
+    const server = getTwilioServer();
+    server.configure({
+      port: this.twilio.port,
+      publicBaseUrl: this.twilio.public_base_url,
+      signingToken: this.twilio.auth_token || this.twilio.secret,
+    });
+
+    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), {
+      dedupOn: "CallSid",
+    });
+
+    server.registerWs(WS_PATH, {
+      onMessage: (ws, data) => this.onWsMessage(ws, data),
+      onClose: (ws) => this.onWsClose(ws),
     });
 
+    // Owner number must never be rate-limited (e.g. urgent rapid retries).
+    if (this.twilio.owner_number) server.exemptFromRateLimit(this.twilio.owner_number);
+
+    await server.start();
+
     log.info(
       {
-        port: this.cfg.port,
-        publicBaseUrl: this.cfg.public_base_url,
-        from: this.cfg.from_number,
-        owner: this.cfg.owner_number,
-        realtimeModel: this.cfg.realtime_model,
-        voice: this.cfg.voice,
+        port: this.twilio.port,
+        publicBaseUrl: this.twilio.public_base_url,
+        from: this.phone.from_number,
+        owner: this.twilio.owner_number,
+        realtimeModel: this.phone.realtime_model,
+        voice: this.phone.voice,
       },
       "phone channel started",
     );
   }
 
   async stop(): Promise<void> {
-    if (this.server) {
-      this.server.stop(true);
-      this.server = null;
-    }
     for (const active of this.active.values()) active.handle.onTwilioClose();
     this.active.clear();
     this.pending.clear();
+    // The shared server is stopped by the daemon's channel teardown — leaving
+    // 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) ---
@@ -174,10 +153,6 @@ class PhoneChannel implements Channel {
       opts.maxMinutes && opts.maxMinutes > 0 ? Math.min(opts.maxMinutes, HARD_MAX_MINUTES) : DEFAULT_MAX_MINUTES;
     const instructions = buildOutboundInstructions(opts.goal, opts.context);
 
-    // Twilio always includes `CallSid` in the form body of the TwiML
-    // webhook, so we don't need to encode it in the URL path — one static
-    // endpoint handles every outbound call, and we look up context by the
-    // CallSid Twilio sends us back.
     const result = await twilioPlaceCall({
       ...creds,
       to: opts.number,
@@ -205,21 +180,14 @@ class PhoneChannel implements Channel {
     return result;
   }
 
-  /**
-   * Wait for an in-flight call to finish. Resolves with the final transcript
-   * once the call has been persisted; returns null if the callSid is unknown.
-   */
   async awaitCallCompletion(callSid: string): Promise<RelayResult | null> {
     const deferred = this.completions.get(callSid);
     return deferred ? deferred.promise : null;
   }
 
-  // --- HTTP handlers ---
-
-  private async handleIncoming(req: Request): Promise<Response> {
-    const { params } = await readForm(req);
-    if (!this.verifySignature(req, params)) return forbidden();
+  // --- HTTP handlers (signature already validated by the shared server) ---
 
+  private async handleIncoming(_req: Request, params: Record<string, string>): Promise<Response> {
     const callSid = params.CallSid || "";
     const from = params.From || "";
     const { label, allowed } = this.classifyCaller(from);
@@ -227,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."));
     }
@@ -254,10 +222,7 @@ class PhoneChannel implements Channel {
     return twimlResponse(streamTwiML(this.buildWssUrl(), { callSid, direction: "inbound" }));
   }
 
-  private async handleOutboundTwiml(req: Request): Promise<Response> {
-    const { params } = await readForm(req);
-    if (!this.verifySignature(req, params)) return forbidden();
-
+  private async handleOutboundTwiml(_req: Request, params: Record<string, string>): Promise<Response> {
     const callSid = params.CallSid || "";
     const pending = this.pending.get(callSid);
     if (!pending) {
@@ -270,9 +235,7 @@ class PhoneChannel implements Channel {
     return twimlResponse(streamTwiML(this.buildWssUrl(), { callSid, direction: "outbound" }));
   }
 
-  private async handleStatus(req: Request): Promise<Response> {
-    const { params } = await readForm(req);
-    if (!this.verifySignature(req, params)) return forbidden();
+  private handleStatus(params: Record<string, string>): Response {
     log.info(
       {
         callSid: params.CallSid,
@@ -285,16 +248,40 @@ class PhoneChannel implements Channel {
     return new Response("", { status: 204 });
   }
 
-  // --- WebSocket bootstrap ---
+  // --- WebSocket plumbing (delegated by shared server to this channel) ---
+
+  private onWsMessage(ws: ServerWebSocket<WsConnectionData>, data: string): void {
+    const sid = (ws.data.channel as { streamSid?: string }).streamSid;
+    if (sid) {
+      const active = this.active.get(sid);
+      if (active) {
+        active.handle.onTwilioMessage(data);
+        return;
+      }
+    }
+    this.bootstrapWsMessage(ws, data).catch((err) => {
+      log.error({ err }, "phone: ws bootstrap failed");
+      try {
+        ws.close();
+      } catch {}
+    });
+  }
+
+  private onWsClose(ws: ServerWebSocket<WsConnectionData>): void {
+    const sid = (ws.data.channel as { streamSid?: string }).streamSid;
+    if (!sid) return;
+    const active = this.active.get(sid);
+    if (active) active.handle.onTwilioClose();
+  }
 
-  private async bootstrapWsMessage(ws: ServerWebSocket<WsData>, data: string): Promise<void> {
+  private async bootstrapWsMessage(ws: ServerWebSocket<WsConnectionData>, data: string): Promise<void> {
     let msg: any;
     try {
       msg = JSON.parse(data);
     } catch {
       return;
     }
-    if (msg.event === "connected") return; // first frame, no streamSid yet
+    if (msg.event === "connected") return;
 
     if (msg.event !== "start") {
       log.warn({ event: msg.event }, "phone: unexpected first ws event");
@@ -321,16 +308,16 @@ class PhoneChannel implements Channel {
 
     const handle = createRelay({
       twilioWs: ws,
-      openAiKey: this.cfg.openai_api_key!,
-      model: this.cfg.realtime_model,
-      voice: this.cfg.voice,
+      openAiKey: this.phone.openai_api_key!,
+      model: this.phone.realtime_model,
+      voice: this.phone.voice,
       context,
     });
 
-    ws.data.streamSid = streamSid;
+    (ws.data.channel as { streamSid?: string }).streamSid = streamSid;
     this.active.set(streamSid, { handle, context, startedAt: pending.startedAt });
 
-    handle.onTwilioMessage(data); // forward the "start" event itself
+    handle.onTwilioMessage(data);
 
     handle.completion
       .then((result) => this.persistCall(context, pending.startedAt, result))
@@ -341,50 +328,36 @@ class PhoneChannel implements Channel {
   // --- Helpers ---
 
   private canStartRealtime(): boolean {
-    return Boolean(this.cfg.openai_api_key && this.cfg.public_base_url);
+    return Boolean(this.phone.openai_api_key && this.twilio.public_base_url);
   }
 
   private buildWssUrl(): string {
-    const base = this.cfg.public_base_url!.replace(/^http/, "ws");
-    return `${base}/twilio/voice/stream`;
+    return getTwilioServer().buildWssUrl(WS_PATH);
   }
 
   private classifyCaller(from: string): { label: string; allowed: boolean } {
-    if (from && from === this.cfg.owner_number) return { label: "Aman", allowed: true };
-    if (from && this.cfg.allowlist.includes(from)) return { label: from, allowed: true };
+    if (from && from === this.twilio.owner_number) return { label: "Aman", allowed: true };
+    if (from && this.twilio.allowlist.includes(from)) return { label: from, allowed: true };
     return { label: from || "unknown", allowed: false };
   }
 
-  private verifySignature(req: Request, params: Record<string, string>): boolean {
-    // X-Twilio-Signature is HMAC-SHA1 with the account's Auth Token. When an
-    // API Key (SK…) + Secret is used for REST auth, the Auth Token is a
-    // separate value — set as TWILIO_AUTH_TOKEN. We fall back to TWILIO_SECRET
-    // so the simple "Account SID + Auth Token" pairing also works.
-    const signingToken = this.cfg.twilio_auth_token || this.cfg.twilio_secret;
-    if (!signingToken) return false;
-    const signature = req.headers.get("X-Twilio-Signature") || "";
-    const fullUrl = this.cfg.public_base_url ? `${this.cfg.public_base_url}${new URL(req.url).pathname}` : req.url;
-    return validateTwilioSignature({ authToken: signingToken, fullUrl, params, signature });
-  }
-
-  private requireCreds(): { accountSid: string; authToken: string } {
-    const sid = this.cfg.twilio_sid;
-    const secret = this.cfg.twilio_secret;
-    if (!sid || !secret)
-      throw new Error("phone: channels.phone.twilio_sid and twilio_secret not set (config.yaml or env)");
-    return { accountSid: sid, authToken: secret };
+  private requireCreds(): { accountSid: string; authSid: string; authSecret: string } {
+    const sid = this.twilio.sid;
+    const secret = this.twilio.secret;
+    if (!sid || !secret) throw new Error("twilio: sid and secret not set (channels.twilio.* in config.yaml or env)");
+    return { accountSid: sid, authSid: sid, authSecret: secret };
   }
 
   private requirePublicBaseUrl(): string {
-    if (!this.cfg.public_base_url)
-      throw new Error("phone: channels.phone.public_base_url not set (config.yaml or PUBLIC_BASE_URL env)");
-    return this.cfg.public_base_url;
+    if (!this.twilio.public_base_url)
+      throw new Error("twilio: public_base_url not set (channels.twilio.public_base_url or PUBLIC_BASE_URL env)");
+    return this.twilio.public_base_url;
   }
 
   private requireFromNumber(): string {
-    if (!this.cfg.from_number)
-      throw new Error("phone: channels.phone.from_number not set (config.yaml or PHONE_FROM_NUMBER env)");
-    return this.cfg.from_number;
+    if (!this.phone.from_number)
+      throw new Error("phone: from_number not set (channels.phone.from_number or PHONE_FROM_NUMBER env)");
+    return this.phone.from_number;
   }
 
   private async persistCall(context: CallContext, startedAt: number, result: RelayResult): Promise<void> {
@@ -432,34 +405,22 @@ class PhoneChannel implements Channel {
 
 // --- Pure helpers ---
 
-async function readForm(req: Request): Promise<{ params: Record<string, string> }> {
-  const body = await req.text();
-  const params: Record<string, string> = {};
-  const usp = new URLSearchParams(body);
-  for (const [k, v] of usp) params[k] = v;
-  return { params };
-}
-
 function twimlResponse(xml: string): Response {
   return new Response(xml, { status: 200, headers: { "Content-Type": "text/xml" } });
 }
 
-function forbidden(): Response {
-  return new Response("invalid signature", { status: 403 });
-}
-
 // --- Factory ---
 
 let _instance: PhoneChannel | null = null;
 
 export function createPhoneChannel(): PhoneChannel | null {
-  const cfg = getConfig().channels.phone;
-  if (!cfg.twilio_sid || !cfg.twilio_secret || !cfg.from_number) return null;
-  _instance = new PhoneChannel(cfg);
+  const { twilio, phone } = getConfig().channels;
+  if (!phone.enabled) return null;
+  if (!twilio.sid || !twilio.secret || !phone.from_number) return null;
+  _instance = new PhoneChannel(phone, twilio);
   return _instance;
 }
 
-/** Used by the place_call MCP tool and CLI test entrypoint. Null if not running. */
 export function getPhoneChannel(): PhoneChannel | null {
   return _instance;
 }

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");
         }