niahere 0.5.0 → 0.5.2

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

package/src/channels/twilio/rest.ts

@@ -73,16 +73,6 @@ export async function placeCall(opts: PlaceCallOpts): Promise<PlaceCallResult> {
   return { callSid: data.sid, status: data.status };
 }
 
-export async function updateCallUrl(opts: TwilioCreds & { callSid: string; url: string }): Promise<void> {
-  const body = new URLSearchParams({ Url: opts.url, Method: "POST" });
-  await twilioPost(opts, `/Calls/${encodeURIComponent(opts.callSid)}.json`, body);
-}
-
-export async function hangupCall(opts: TwilioCreds & { callSid: string }): Promise<void> {
-  const body = new URLSearchParams({ Status: "completed" });
-  await twilioPost(opts, `/Calls/${encodeURIComponent(opts.callSid)}.json`, body);
-}
-
 // --- Messages (SMS / WhatsApp) ---
 
 export interface SendMessageOpts extends TwilioCreds {
@@ -111,24 +101,3 @@ export async function sendMessage(opts: SendMessageOpts): Promise<SendMessageRes
 }
 
 // --- Phone number config (update inbound webhook on a number) ---
-
-export async function updateIncomingPhoneNumber(
-  opts: TwilioCreds & {
-    phoneNumberSid: string;
-    voiceUrl?: string;
-    voiceMethod?: "GET" | "POST";
-    smsUrl?: string;
-    smsMethod?: "GET" | "POST";
-    statusCallback?: string;
-    statusCallbackMethod?: "GET" | "POST";
-  },
-): Promise<void> {
-  const body = new URLSearchParams();
-  if (opts.voiceUrl !== undefined) body.set("VoiceUrl", opts.voiceUrl);
-  if (opts.voiceMethod) body.set("VoiceMethod", opts.voiceMethod);
-  if (opts.smsUrl !== undefined) body.set("SmsUrl", opts.smsUrl);
-  if (opts.smsMethod) body.set("SmsMethod", opts.smsMethod);
-  if (opts.statusCallback !== undefined) body.set("StatusCallback", opts.statusCallback);
-  if (opts.statusCallbackMethod) body.set("StatusCallbackMethod", opts.statusCallbackMethod);
-  await twilioPost(opts, `/IncomingPhoneNumbers/${encodeURIComponent(opts.phoneNumberSid)}.json`, body);
-}

package/src/channels/twilio/server.ts

@@ -248,8 +248,3 @@ export function getTwilioServer(): TwilioServer {
   if (!_instance) _instance = new TwilioServerImpl();
   return _instance;
 }
-
-/** Test-only: drop the singleton so tests get a fresh server. */
-export function resetTwilioServer(): void {
-  _instance = null;
-}

package/src/channels/twilio/shared.ts

@@ -0,0 +1,36 @@
+import type { TwilioConfig } from "../../types";
+import { log } from "../../utils/log";
+
+/** Bits every Twilio-backed channel (sms, whatsapp) needs identically. */
+
+const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
+
+/** Ack an inbound webhook immediately. Replies go out over REST instead, so a
+ *  slow engine cannot blow Twilio's ~15s webhook budget. */
+export function ackTwiml(): Response {
+  return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+}
+
+export function isAllowedSender(twilio: TwilioConfig, remoteE164: string): boolean {
+  if (twilio.owner_number && remoteE164 === twilio.owner_number) return true;
+  return twilio.allowlist.includes(remoteE164);
+}
+
+type StatusLogger = (label: string, fields: Record<string, unknown>) => void;
+
+const logStatus: StatusLogger = (label, fields) => log.info(fields, `${label}: delivery status`);
+
+/** Record a delivery-status callback and ack it. */
+export function deliveryStatusAck(
+  label: string,
+  params: Record<string, string>,
+  record: StatusLogger = logStatus,
+): Response {
+  record(label, {
+    messageSid: params.MessageSid,
+    status: params.MessageStatus,
+    errorCode: params.ErrorCode,
+    to: params.To,
+  });
+  return new Response("", { status: 204 });
+}

package/src/channels/whatsapp.ts

@@ -20,10 +20,12 @@
 import { getMcpServers } from "../mcp";
 import { Message } from "../db/models";
 import { runMigrations } from "../db/migrate";
-import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { ChatSessions, chainLock } from "./common/chat-session";
+import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 import type { Attachment, Channel, ChatState, Outbound, TwilioConfig, WhatsappConfig, PhoneConfig } from "../types";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { classifyMime, prepareImage, validateAttachment } from "../utils/attachment";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
@@ -32,7 +34,6 @@ import { transcribeAudio } from "./twilio/transcribe";
 
 const TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1000;
 const WA_PREFIX = "whatsapp:";
-const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
 const CHUNK_LIMIT = 4096;
 const RESET_RE = /^\s*\/(reset|new)\s*$/i;
 const VOICE_MIME_PREFIX = "audio/";
@@ -42,13 +43,14 @@ class WhatsAppChannel implements Channel {
   private readonly twilio: TwilioConfig;
   private readonly whatsapp: WhatsappConfig;
   private readonly phone: PhoneConfig;
-  private readonly chats = new Map<string, ChatState>();
+  private readonly chats: ChatSessions<string>;
   private readonly lastInboundAt = new Map<string, number>();
 
   constructor(twilio: TwilioConfig, whatsapp: WhatsappConfig, phone: PhoneConfig) {
     this.twilio = twilio;
     this.whatsapp = whatsapp;
     this.phone = phone;
+    this.chats = new ChatSessions(roomPrefix, () => ({ channel: "whatsapp", mcpServers: getMcpServers() }));
   }
 
   async start(): Promise<void> {
@@ -86,8 +88,7 @@ class WhatsAppChannel implements Channel {
   }
 
   async stop(): Promise<void> {
-    for (const state of this.chats.values()) state.engine.close();
-    this.chats.clear();
+    this.chats.closeAll();
   }
 
   /** Outbound to the owner — used by send_message MCP tool. WhatsApp has no threading. */
@@ -108,9 +109,9 @@ class WhatsAppChannel implements Channel {
     const from = (params.From || "").replace(/^whatsapp:/, "");
     const body = (params.Body || "").trim();
 
-    if (!this.isAllowed(from)) {
+    if (!isAllowedSender(this.twilio, from)) {
       log.warn({ from }, "whatsapp: rejecting non-allowlisted sender");
-      return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+      return ackTwiml();
     }
 
     this.lastInboundAt.set(from, Date.now());
@@ -118,20 +119,20 @@ class WhatsAppChannel implements Channel {
     if (RESET_RE.test(body)) {
       // Serialize through the same lock so a /reset chasing an in-flight
       // engine.send() waits its turn instead of yanking the engine away.
-      const state = await this.getState(from);
+      const state = await this.chats.get(from);
       chainLock(state, async () => {
-        const newState = await this.restartChat(from);
+        const newState = await this.chats.rotate(from);
         await this.sendTextTo(
           from,
-          `New conversation started (room ${this.roomPrefix(from)}-${newState.roomIndex}).`,
+          `New conversation started (room ${roomPrefix(from)}-${newState.roomIndex}).`,
         ).catch((err) => log.warn({ err, from }, "whatsapp: failed to send reset confirmation"));
       });
-      return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+      return ackTwiml();
     }
 
     const descriptors = extractMedia(params);
 
-    const state = await this.getState(from);
+    const state = await this.chats.get(from);
     chainLock(state, async () => {
       let userText = body;
       let attachments: Attachment[] | undefined;
@@ -162,7 +163,7 @@ class WhatsAppChannel implements Channel {
             } catch (err) {
               log.error({ err, from }, "whatsapp: voice transcription failed");
               voiceParts.push(
-                `[voice note: transcription failed — ${err instanceof Error ? err.message : String(err)}]`,
+                `[voice note: transcription failed — ${errMsg(err)}]`,
               );
             }
             continue;
@@ -171,7 +172,7 @@ class WhatsAppChannel implements Channel {
           const error = validateAttachment(item.data);
           if (error) {
             log.warn({ from, mime: item.mime, error }, "whatsapp: rejecting attachment");
-            await this.sendTextTo(from, `[error] ${error}`).catch(() => {});
+            await ignore(this.sendTextTo(from, `[error] ${error}`), "reply engine error");
             continue;
           }
 
@@ -203,32 +204,23 @@ class WhatsAppChannel implements Channel {
         const reply = result.trim() || "(no response)";
         try {
           await this.sendTextTo(from, reply);
-          if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
         } 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) {
         log.error({ err, from }, "whatsapp: engine error");
-        const errText = err instanceof Error ? err.message : String(err);
-        await this.sendTextTo(from, `[error] ${errText}`).catch(() => {});
+        const errText = errMsg(err);
+        await ignore(this.sendTextTo(from, `[error] ${errText}`), "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,
-      },
-      "whatsapp: delivery status",
-    );
-    return new Response("", { status: 204 });
+    return deliveryStatusAck("whatsapp", params);
   }
 
   // --- Outbound ---
@@ -301,36 +293,10 @@ class WhatsAppChannel implements Channel {
     return true;
   }
 
-  // --- 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 roomPrefix(remoteE164: string): string {
-    return `wa-${remoteE164}`;
-  }
-
-  private async getState(remoteE164: string): Promise<ChatState> {
-    let state = this.chats.get(remoteE164);
-    if (state) return state;
-    state = await openChatEngine(this.roomPrefix(remoteE164), () => ({
-      channel: "whatsapp",
-      mcpServers: getMcpServers(),
-    }));
-    this.chats.set(remoteE164, state);
-    return state;
-  }
+}
 
-  private async restartChat(remoteE164: string): Promise<ChatState> {
-    const state = await rotateRoom(this.roomPrefix(remoteE164), this.chats.get(remoteE164), () => ({
-      channel: "whatsapp",
-      mcpServers: getMcpServers(),
-    }));
-    this.chats.set(remoteE164, state);
-    return state;
-  }
+function roomPrefix(remoteE164: string): string {
+  return `wa-${remoteE164}`;
 }
 
 /**

package/src/chat/engine.ts

@@ -4,10 +4,13 @@ import { buildSystemPrompt, buildContextSuffix, getSessionContext } from "./iden
 import { buildEmployeePrompt } from "./employee-prompt";
 import { getEmployee } from "../core/employees";
 import { getAgentDefinitions, scanAgents } from "../core/agents";
+import { gapMarker } from "./gap-marker";
+import { getConfig } from "../utils/config";
 import { Session, Message, ActiveEngine, Job } from "../db/models";
 import type { Attachment, SendResult, SendCallbacks, ChatEngine, EngineOptions } from "../types";
 import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
+import { asError, errMsg, ignore } from "../utils/errors";
 import { registerActiveHandle, unregisterActiveHandle } from "../core/active-handles";
 import { resolveJobPrompt } from "../core/job-prompt";
 import { truncate } from "../utils/format-activity";
@@ -169,7 +172,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     clearIdleTimer();
     clearLongRunningTimer();
     if (session) {
-      await session.close().catch(() => {});
+      await ignore(session.close(), "close chat session");
       session = null;
     }
     unregisterActiveHandle(room);
@@ -218,7 +221,13 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
       return room;
     },
 
-    async send(userMessage: string, callbacks?: SendCallbacks, attachments?: Attachment[]) {
+    async send(rawMessage: string, callbacks?: SendCallbacks, attachments?: Attachment[]) {
+      // Date the turn when time has visibly passed. Computed before anything is
+      // saved, and used for BOTH the send and the save so the stored record is
+      // exactly what the model received.
+      const marker = gapMarker(new Date(), await Message.getLastAt(room).catch(() => null), getConfig().timezone);
+      const userMessage = marker ? `${marker}\n${rawMessage}` : rawMessage;
+
       // Re-probe from the top once the failed provider's cooldown lapses, so a
       // brief outage does not pin the conversation to the fallback for good.
       if (!cursor.atHead) {
@@ -239,7 +248,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
 
       // Cancel any pending finalization — session is active again
       if (sessionId) {
-        cancelPending(sessionId).catch(() => {});
+        void ignore(cancelPending(sessionId), "cancel pending finalization");
       }
 
       await ActiveEngine.register(room, channel);
@@ -266,7 +275,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
           // A backend that cannot start must not take the turn down.
           const next = cursor.advance("provider");
           log.warn({ room, err: String(err), to: next && describeEntry(next) }, "chat backend failed to start");
-          if (!next) throw err instanceof Error ? err : new Error(String(err));
+          if (!next) throw asError(err);
           handoff = await buildHandoff(userMessage);
           continue;
         }
@@ -318,7 +327,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                     messageId = await Message.save({ ...saveParams, metadata: undefined });
                   }
                   await Session.touch(sessionId);
-                  Session.accumulateMetadata(sessionId, { ...(ev.metadata ?? {}), channel }).catch(() => {});
+                  void ignore(Session.accumulateMetadata(sessionId, { ...(ev.metadata ?? {}), channel }), "accumulate session metadata");
                 }
                 result = { result: ev.text, costUsd, turns, messageId };
                 break;
@@ -340,11 +349,11 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
             }
           }
         } catch (err) {
-          await ActiveEngine.unregister(room).catch(() => {});
+          await ignore(ActiveEngine.unregister(room), "unregister active-engine");
           clearLongRunningTimer();
           inFlight = false;
           if (sess.backendSessionId) sessionId = sess.backendSessionId;
-          throw err instanceof Error ? err : new Error(String(err));
+          throw asError(err);
         }
 
         // Re-read the backend session id post-send so finalize/DB target it.
@@ -379,7 +388,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
         }
       }
       await teardown();
-      await ActiveEngine.unregister(room).catch(() => {});
+      await ignore(ActiveEngine.unregister(room), "unregister active-engine");
     },
   };
 }

package/src/chat/gap-marker.ts

@@ -0,0 +1,63 @@
+/**
+ * Dates a user turn when time has visibly passed.
+ *
+ * A resumed session replays its transcript with no timestamps, so a reply from
+ * three days ago reads as present-tense — ask "what should I wear?" twice in a
+ * week and the model happily repeats Monday's weather. The marker is prefixed
+ * onto the turn that is sent AND stored, so the transcript dates itself from
+ * then on.
+ */
+
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+
+/** Gap that counts as "time has passed" even within one day. */
+export const GAP_THRESHOLD_MS = 2 * HOUR_MS;
+
+const LOCALE = "en-US";
+
+function localDay(date: Date, timezone: string): string {
+  return new Intl.DateTimeFormat("en-CA", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone: timezone,
+  }).format(date);
+}
+
+function plural(n: number, unit: string): string {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
+
+/** Floored, never rounded up: the absolute stamp alongside it carries the
+ *  precision, so this should not claim more time passed than actually did. */
+function elapsed(ms: number): string {
+  if (ms >= DAY_MS) return plural(Math.floor(ms / DAY_MS), "day");
+  if (ms >= HOUR_MS) return plural(Math.floor(ms / HOUR_MS), "hour");
+  return plural(Math.max(1, Math.floor(ms / MINUTE_MS)), "minute");
+}
+
+/**
+ * The prefix for this turn, or null when the conversation is still continuous.
+ * Fires when the local date has changed or the gap exceeds the threshold.
+ */
+export function gapMarker(now: Date, last: Date | null, timezone: string): string | null {
+  if (!last) return null;
+
+  const gap = now.getTime() - last.getTime();
+  const dayChanged = localDay(now, timezone) !== localDay(last, timezone);
+  if (gap < GAP_THRESHOLD_MS && !dayChanged) return null;
+
+  const stamp = new Intl.DateTimeFormat(LOCALE, {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: timezone,
+  }).format(now);
+
+  return `[${stamp} — ${elapsed(gap)} since the last message]`;
+}

package/src/chat/repl.ts

@@ -1,4 +1,5 @@
 import * as readline from "readline";
+import { errMsg, ignore } from "../utils/errors";
 import { createChatEngine } from "./engine";
 import { runMigrations } from "../db/migrate";
 import { closeDb } from "../db/connection";
@@ -118,7 +119,7 @@ export async function startRepl(
   try {
     await runMigrations();
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = errMsg(err);
     console.error(`Failed to connect to postgres: ${msg}`);
     console.error(`Set database_url in ~/.niahere/config.yaml or run \`nia init\``);
     process.exit(1);
@@ -218,7 +219,7 @@ export async function startRepl(
       process.stdout.write("\n\n");
     } catch (err) {
       status.stop();
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = errMsg(err);
       console.error(`\n${DIM}error:${RESET} ${msg}\n`);
     }
   }
@@ -252,9 +253,8 @@ export async function startRepl(
   rl.on("close", async () => {
     console.log(`\n${DIM}bye${RESET}`);
     await engine.close();
-    closeDb()
-      .catch(() => {})
-      .finally(() => process.exit(0));
+    await ignore(closeDb(), "close db on exit");
+    process.exit(0);
   });
 
   process.on("SIGINT", () => {