niahere 0.4.2 → 0.4.4

package/package.json

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

package/src/channels/sms.ts

@@ -131,8 +131,7 @@ class SmsChannel implements Channel {
 
   private async sendTo(remoteE164: string, body: string): Promise<void> {
     if (!this.twilio.sid || !this.twilio.secret) {
-      log.warn("sms: twilio sid/secret missing, cannot send");
-      return;
+      throw new Error("sms: twilio sid/secret missing, cannot send");
     }
     try {
       const res = await twilioSendMessage({
@@ -147,6 +146,10 @@ class SmsChannel implements Channel {
       log.info({ to: remoteE164, sid: res.messageSid, status: res.status }, "sms: sent");
     } catch (err) {
       log.error({ err, to: remoteE164 }, "sms: send failed");
+      // Rethrow so deliver() propagates the failure: the inbound handler falls
+      // back to an error reply, and the send_message tool reports "Failed to
+      // send" instead of falsely claiming delivery.
+      throw err;
     }
   }
 

package/src/channels/whatsapp.ts

@@ -121,7 +121,10 @@ class WhatsAppChannel implements Channel {
       const state = await this.getState(from);
       chainLock(state, async () => {
         const newState = await this.restartChat(from);
-        await this.sendTextTo(from, `New conversation started (room ${this.roomPrefix(from)}-${newState.roomIndex}).`);
+        await this.sendTextTo(
+          from,
+          `New conversation started (room ${this.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" } });
     }
@@ -231,7 +234,7 @@ class WhatsAppChannel implements Channel {
   // --- Outbound ---
 
   private async sendTextTo(remoteE164: string, body: string): Promise<void> {
-    if (!this.canSend(remoteE164)) return;
+    if (!this.canSend(remoteE164)) throw new Error("whatsapp: cannot send (missing creds or outside 24h window)");
     const converted = toWhatsAppMarkdown(body);
     const chunks = chunkText(converted, CHUNK_LIMIT);
     for (const chunk of chunks) {
@@ -240,14 +243,14 @@ class WhatsAppChannel implements Channel {
   }
 
   private async sendMediaTo(remoteE164: string, data: Buffer, mimeType: string, filename?: string): Promise<void> {
-    if (!this.canSend(remoteE164)) return;
+    if (!this.canSend(remoteE164)) throw new Error("whatsapp: cannot send (missing creds or outside 24h window)");
     const ext = filename ? extOf(filename) : undefined;
     let mediaUrl: string;
     try {
       mediaUrl = await getTwilioServer().serveMedia(new Uint8Array(data), mimeType, ext);
     } catch (err) {
       log.error({ err }, "whatsapp: serveMedia failed");
-      return;
+      throw err;
     }
     await this.postMessage(remoteE164, "", [mediaUrl]);
   }

package/src/chat/engine.ts

@@ -37,11 +37,10 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
   const { room, channel, resume, mcpServers } = opts;
   let systemPrompt = buildSystemPrompt("chat", channel);
 
-  // Inject recent session summaries for continuity
+  // Recent session summaries for continuity. Appended AFTER persona selection
+  // below — the employee/agent branches replace systemPrompt wholesale, so
+  // injecting here would be discarded for those contexts.
   const sessionContext = await getSessionContext(room);
-  if (sessionContext) {
-    systemPrompt += "\n\n" + sessionContext;
-  }
 
   // Context overrides: employee > agent > job > default
   let cwd = homedir();
@@ -86,6 +85,11 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     }
   }
 
+  // Continuity summaries — appended after persona so employee/agent contexts keep them.
+  if (sessionContext) {
+    systemPrompt += "\n\n" + sessionContext;
+  }
+
   // Watch mode: inject behavior into system prompt
   if (opts.watchBehavior) {
     const { channel: watchChannel, behavior } = opts.watchBehavior;
@@ -312,6 +316,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
           log.warn({ room, to: backends[backendIndex]!.name }, "chat provider down, failing over to next backend");
           await teardown(); // close the dead session so ensureSession opens the next backend
           sessionId = null; // a cross-backend session id is meaningless; start fresh
+          userSaved = false; // re-save the user turn under the new backend's session
           continue;
         }
         break;

package/src/core/scheduler.ts

@@ -40,10 +40,10 @@ async function tick(): Promise<void> {
 
   for (const job of dueJobs) {
     if (!job.always && !isWithinActiveHours()) {
-      try {
-        const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
-        if (nextRun) await Job.markRun(job.name, nextRun).catch(() => {});
-      } catch {}
+      // Leave next_run_at untouched so the job stays due and fires as soon as
+      // active hours resume. Rescheduling here would advance a cron job whose
+      // only fire time sits outside the window to the next (also-outside)
+      // occurrence — starving it forever.
       log.info({ job: job.name }, "scheduler: skipping — outside active hours");
       continue;
     }

package/src/db/models/message.ts

@@ -4,10 +4,15 @@ import type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, Session
 
 export type DeliveryStatus = "pending" | "sent" | "failed";
 
-export async function save(params: SaveMessageParams & { deliveryStatus?: DeliveryStatus; metadata?: Record<string, unknown> }): Promise<number> {
+export async function save(
+  params: SaveMessageParams & { deliveryStatus?: DeliveryStatus; metadata?: Record<string, unknown> },
+): Promise<number> {
   const sql = getSql();
   const status = params.deliveryStatus || "sent";
-  const meta = params.metadata ? JSON.stringify(params.metadata) : null;
+  // Pass the object straight through: the postgres driver serializes it to a
+  // real jsonb object. Pre-stringifying stores a double-encoded string scalar,
+  // which silently breaks every `metadata->>'key'` filter (e.g. notifications).
+  const meta = params.metadata ? sql.json(params.metadata as Parameters<typeof sql.json>[0]) : null;
   const rows = await sql`
     INSERT INTO messages (session_id, room, sender, content, is_from_agent, delivery_status, metadata)
     VALUES (${params.sessionId}, ${params.room}, ${params.sender}, ${params.content}, ${params.isFromAgent}, ${status}, ${meta})
@@ -21,29 +26,6 @@ export async function updateDeliveryStatus(id: number, status: DeliveryStatus):
   await sql`UPDATE messages SET delivery_status = ${status} WHERE id = ${id}`;
 }
 
-export async function getUndelivered(room?: string): Promise<Array<{ id: number; room: string; content: string; createdAt: string }>> {
-  const sql = getSql();
-  const rows = room
-    ? await sql`
-        SELECT id, room, content, created_at
-        FROM messages
-        WHERE delivery_status = 'failed' AND is_from_agent = true AND room = ${room}
-        ORDER BY created_at ASC
-      `
-    : await sql`
-        SELECT id, room, content, created_at
-        FROM messages
-        WHERE delivery_status = 'failed' AND is_from_agent = true
-        ORDER BY created_at ASC
-      `;
-  return rows.map((r) => ({
-    id: r.id,
-    room: r.room,
-    content: r.content,
-    createdAt: String(r.created_at),
-  }));
-}
-
 export async function getRecent(limit = 20, room?: string): Promise<RecentMessage[]> {
   const sql = getSql();
   const rows = room

package/src/db/models/session.ts

@@ -141,7 +141,10 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     }
   }
 
-  const delta = JSON.stringify({
+  // Bind deltas as jsonb via sql.json — pre-stringifying would store a
+  // double-encoded string scalar, making every `->>` extraction return NULL
+  // and silently zeroing all accumulated totals.
+  const delta = sql.json({
     total_cost_usd: (resultMeta.cost_usd as number) || 0,
     total_turns: (resultMeta.turns as number) || 0,
     total_duration_ms: (resultMeta.duration_ms as number) || 0,
@@ -152,22 +155,24 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     total_cache_creation_tokens: cacheCreationTokens,
     message_count: 1,
     models_used: newModels,
-    channel: resultMeta.channel || null,
+    channel: (resultMeta.channel as string) || null,
   });
+  const modelsDelta = sql.json(newModels);
 
   // Atomic accumulate — no read-then-write race
   await sql`
     UPDATE sessions SET metadata = jsonb_build_object(
-      'total_cost_usd',              COALESCE((metadata->>'total_cost_usd')::real, 0)              + (${delta}::jsonb->>'total_cost_usd')::real,
-      'total_turns',                  COALESCE((metadata->>'total_turns')::int, 0)                  + (${delta}::jsonb->>'total_turns')::int,
-      'total_duration_ms',            COALESCE((metadata->>'total_duration_ms')::real, 0)            + (${delta}::jsonb->>'total_duration_ms')::real,
-      'total_duration_api_ms',        COALESCE((metadata->>'total_duration_api_ms')::real, 0)        + (${delta}::jsonb->>'total_duration_api_ms')::real,
-      'total_input_tokens',           COALESCE((metadata->>'total_input_tokens')::int, 0)            + (${delta}::jsonb->>'total_input_tokens')::int,
-      'total_output_tokens',          COALESCE((metadata->>'total_output_tokens')::int, 0)           + (${delta}::jsonb->>'total_output_tokens')::int,
-      'total_cache_read_tokens',      COALESCE((metadata->>'total_cache_read_tokens')::int, 0)       + (${delta}::jsonb->>'total_cache_read_tokens')::int,
-      'total_cache_creation_tokens',  COALESCE((metadata->>'total_cache_creation_tokens')::int, 0)   + (${delta}::jsonb->>'total_cache_creation_tokens')::int,
+      'total_cost_usd',              COALESCE((metadata->>'total_cost_usd')::real, 0)              + (${delta}->>'total_cost_usd')::real,
+      'total_turns',                  COALESCE((metadata->>'total_turns')::int, 0)                  + (${delta}->>'total_turns')::int,
+      'total_duration_ms',            COALESCE((metadata->>'total_duration_ms')::real, 0)            + (${delta}->>'total_duration_ms')::real,
+      'total_duration_api_ms',        COALESCE((metadata->>'total_duration_api_ms')::real, 0)        + (${delta}->>'total_duration_api_ms')::real,
+      'total_input_tokens',           COALESCE((metadata->>'total_input_tokens')::int, 0)            + (${delta}->>'total_input_tokens')::int,
+      'total_output_tokens',          COALESCE((metadata->>'total_output_tokens')::int, 0)           + (${delta}->>'total_output_tokens')::int,
+      'total_cache_read_tokens',      COALESCE((metadata->>'total_cache_read_tokens')::int, 0)       + (${delta}->>'total_cache_read_tokens')::int,
+      'total_cache_creation_tokens',  COALESCE((metadata->>'total_cache_creation_tokens')::int, 0)   + (${delta}->>'total_cache_creation_tokens')::int,
       'message_count',                COALESCE((metadata->>'message_count')::int, 0)                 + 1,
-      'models_used',                  COALESCE(metadata->'models_used', '[]'::jsonb) || ${JSON.stringify(newModels)}::jsonb,
+      'models_used',                  (SELECT COALESCE(jsonb_agg(DISTINCT e), '[]'::jsonb)
+                                         FROM jsonb_array_elements(COALESCE(metadata->'models_used', '[]'::jsonb) || ${modelsDelta}) AS e),
       'channel',                      COALESCE(metadata->>'channel', ${(resultMeta.channel as string) || null})
     )
     WHERE id = ${id}