niahere 0.5.0 → 0.5.1

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", () => {

package/src/cli/config.ts

@@ -0,0 +1,71 @@
+import { readRawConfig, updateRawConfig } from "../utils/config";
+
+const USAGE = [
+  "Usage: nia config <set|get|list>",
+  "  nia config set <key> <value>  — set a config value",
+  "  nia config get <key>          — get a config value",
+  "  nia config list               — show all config",
+].join("\n");
+
+/** Booleans and integers are written as their real types, not strings. */
+function parseValue(raw: string): unknown {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^\d+$/.test(raw)) return Number(raw);
+  return raw;
+}
+
+/** Expand `a.b.c` into `{ a: { b: { c: value } } }` for a merging write. */
+function nest(key: string, value: unknown): Record<string, unknown> {
+  const parts = key.split(".");
+  const root: Record<string, unknown> = {};
+  let cursor = root;
+  for (const part of parts.slice(0, -1)) {
+    cursor[part] = {};
+    cursor = cursor[part] as Record<string, unknown>;
+  }
+  cursor[parts[parts.length - 1]!] = value;
+  return root;
+}
+
+function readPath(raw: unknown, key: string): unknown {
+  let val = raw;
+  for (const part of key.split(".")) {
+    if (val && typeof val === "object") val = (val as Record<string, unknown>)[part];
+    else return undefined;
+  }
+  return val;
+}
+
+export async function configCommand(sub?: string, key?: string, value?: string): Promise<void> {
+  if (sub === "set" && key) {
+    if (!value) {
+      console.error("Usage: nia config set <key> <value>");
+      process.exit(1);
+    }
+    updateRawConfig(nest(key, parseValue(value)));
+    console.log(`${key} = ${value}`);
+    return;
+  }
+
+  if (sub === "get" && key) {
+    const val = readPath(readRawConfig(), key);
+    if (val === undefined) {
+      console.log(`${key}: (not set)`);
+    } else if (typeof val === "object") {
+      const yaml = (await import("js-yaml")).default;
+      console.log(yaml.dump(val, { lineWidth: -1 }).trim());
+    } else {
+      console.log(`${key} = ${val}`);
+    }
+    return;
+  }
+
+  if (!sub || sub === "list") {
+    const yaml = (await import("js-yaml")).default;
+    console.log(yaml.dump(readRawConfig(), { lineWidth: -1 }).trim());
+    return;
+  }
+
+  console.log(USAGE);
+}