niahere 0.2.43 → 0.2.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/channels/slack.ts

@@ -7,7 +7,7 @@ import type { Channel, ChatState, Attachment, AttachmentType } from "../types";
 import { getConfig, updateRawConfig, resetConfig } from "../utils/config";
 import { relativeTime } from "../utils/format";
 import { runMigrations } from "../db/migrate";
-import { Session } from "../db/models";
+import { Session, Message } from "../db/models";
 import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
 import { getNiaHome, getPaths } from "../utils/paths";
@@ -493,7 +493,7 @@ class SlackChannel implements Channel {
           .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to add thinking reaction"));
 
         try {
-          const { result } = await state.engine.send(text, {
+          const { result, messageId } = await state.engine.send(text, {
             onActivity(status) {
               log.debug({ status }, "slack engine activity");
             },
@@ -504,22 +504,27 @@ class SlackChannel implements Channel {
           // [NO_REPLY] or empty = agent chose not to respond (thread judgement)
           if (!reply || cleanSentinel(reply) === "[NO_REPLY]") {
             log.info({ channel: msg.channel, key }, "slack: agent chose not to reply");
+            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
             return;
           }
 
-          if (replyThreadTs) {
-            await client.chat.postMessage({
-              channel: msg.channel,
-              text: reply,
-              thread_ts: replyThreadTs,
-            });
-          } else {
-            await say(reply);
+          try {
+            if (replyThreadTs) {
+              await client.chat.postMessage({
+                channel: msg.channel,
+                text: reply,
+                thread_ts: replyThreadTs,
+              });
+            } else {
+              await say(reply);
+            }
+            if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+            log.info({ channel: msg.channel, key, chars: reply.length }, "slack reply sent");
+          } catch (sendErr) {
+            if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+            throw sendErr;
           }
-
-          log.info({ channel: msg.channel, key, chars: reply.length }, "slack reply sent");
         } catch (err) {
-
           const errText = err instanceof Error ? err.message : String(err);
           log.error({ err, channel: msg.channel }, "slack message processing failed");
 
@@ -530,7 +535,7 @@ class SlackChannel implements Channel {
               thread_ts: replyThreadTs,
             }).catch(() => {});
           } else {
-            await say(`[error] ${errText}`);
+            await say(`[error] ${errText}`).catch(() => {});
           }
         } finally {
           await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })

package/src/channels/telegram.ts

@@ -3,7 +3,7 @@ import { createChatEngine } from "../chat/engine";
 import type { Channel, ChatState, Attachment } from "../types";
 import { getConfig, updateRawConfig } from "../utils/config";
 import { runMigrations } from "../db/migrate";
-import { Session } from "../db/models";
+import { Session, Message } from "../db/models";
 import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
@@ -136,16 +136,21 @@ class TelegramChannel implements Channel {
       bot.api.sendChatAction(chatId, "typing").catch(() => {});
 
       try {
-        const { result } = await state.engine.send(text, {}, attachments);
+        const { result, messageId } = await state.engine.send(text, {}, attachments);
 
         const reply = result.trim() || "(no response)";
         try {
-          await bot.api.sendMessage(chatId, reply, { parse_mode: "MarkdownV2" });
-        } catch {
-          await bot.api.sendMessage(chatId, reply).catch(() => {});
+          try {
+            await bot.api.sendMessage(chatId, reply, { parse_mode: "MarkdownV2" });
+          } catch {
+            await bot.api.sendMessage(chatId, reply);
+          }
+          if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+          log.info({ chatId, chars: result.length }, "telegram reply sent");
+        } catch (sendErr) {
+          if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+          throw sendErr;
         }
-
-        log.info({ chatId, chars: result.length }, "telegram reply sent");
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
         log.error({ err, chatId }, "telegram message processing failed");

package/src/chat/engine.ts

@@ -10,8 +10,11 @@ import { getAgentDefinitions } from "../core/agents";
 import { Session, Message, ActiveEngine } from "../db/models";
 import type { Attachment, SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "../types";
 import { truncate, formatToolUse } from "../utils/format-activity";
+import { consolidateSession } from "../core/consolidator";
+import { log } from "../utils/log";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
+const LONG_RUNNING_WARN = 30 * 60 * 1000; // 30 minutes
 
 interface SDKUserMessage {
   type: "user";
@@ -128,20 +131,57 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
   let queryHandle: Query | null = null;
   let pending: PendingResult | null = null;
   let idleTimer: ReturnType<typeof setTimeout> | null = null;
+  let longRunningTimer: ReturnType<typeof setTimeout> | null = null;
+  let longRunningWarned = false;
   let alive = false;
+  let messageCount = 0;
+
+  function clearIdleTimer() {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  }
 
   function resetIdleTimer() {
-    if (idleTimer) clearTimeout(idleTimer);
-    idleTimer = setTimeout(() => {
+    clearIdleTimer();
+    idleTimer = setTimeout(async () => {
+      if (pending) {
+        // Don't tear down while a request is in flight
+        log.warn({ room }, "idle timer fired while request pending, skipping teardown");
+        return;
+      }
+      // Memory consolidation — "hippocampal replay" before sleep
+      if (sessionId && messageCount > 0) {
+        consolidateSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "consolidation failed during idle teardown");
+        });
+      }
       teardown();
     }, IDLE_TIMEOUT);
   }
 
-  function teardown() {
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = null;
+  function clearLongRunningTimer() {
+    if (longRunningTimer) {
+      clearTimeout(longRunningTimer);
+      longRunningTimer = null;
     }
+    longRunningWarned = false;
+  }
+
+  function startLongRunningTimer() {
+    clearLongRunningTimer();
+    longRunningTimer = setTimeout(() => {
+      if (pending) {
+        longRunningWarned = true;
+        log.warn({ room, elapsed: LONG_RUNNING_WARN / 1000 }, "engine request running for 30+ minutes");
+      }
+    }, LONG_RUNNING_WARN);
+  }
+
+  function teardown() {
+    clearIdleTimer();
+    clearLongRunningTimer();
     if (stream) {
       stream.end();
       stream = null;
@@ -207,6 +247,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                 content: pending.userMessage,
                 isFromAgent: false,
               });
+              messageCount++;
             }
           }
 
@@ -285,31 +326,44 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
               const costUsd = (message as any).total_cost_usd as number;
               const turns = (message as any).num_turns as number;
 
+              let messageId: number | undefined;
               if (sessionId && resultText) {
-                await Message.save({
+                messageId = await Message.save({
                   sessionId,
                   room,
                   sender: "nia",
                   content: resultText,
                   isFromAgent: true,
+                  deliveryStatus: "pending",
                 });
                 await Session.touch(sessionId);
               }
 
               await ActiveEngine.unregister(room);
-              pending.resolve({ result: resultText, costUsd, turns });
+              clearLongRunningTimer();
+              pending.resolve({ result: resultText, costUsd, turns, messageId });
               pending = null;
               resetIdleTimer();
             } else {
               const errors = (message as any).errors;
               const errorText = `[error] ${errors?.join(", ") || "unknown error"}`;
               await ActiveEngine.unregister(room);
+              clearLongRunningTimer();
               pending.resolve({ result: errorText, costUsd: 0, turns: 0 });
               pending = null;
               resetIdleTimer();
             }
           }
         }
+
+        // Stream ended without a result — subprocess exited or was killed
+        if (pending) {
+          const partial = pending.accumulatedText;
+          log.error({ room, partialChars: partial.length }, "query stream ended without result, rejecting pending request");
+          await ActiveEngine.unregister(room).catch(() => {});
+          pending.reject(new Error(`stream ended without result (${partial.length} chars accumulated)`));
+          pending = null;
+        }
       } catch (err) {
         if (pending) {
           await ActiveEngine.unregister(room).catch(() => {});
@@ -317,6 +371,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
           pending = null;
         }
       } finally {
+        clearLongRunningTimer();
         alive = false;
         stream = null;
         queryHandle = null;
@@ -334,6 +389,10 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     },
 
     async send(userMessage: string, callbacks?: SendCallbacks, attachments?: Attachment[]) {
+      // Clear idle timer — engine is not idle while processing a request
+      clearIdleTimer();
+      startLongRunningTimer();
+
       await ActiveEngine.register(room, channel);
 
       if (!alive || !stream) {
@@ -356,6 +415,12 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
     },
 
     close() {
+      // Memory consolidation on explicit close (skip if mid-turn — transcript is incomplete)
+      if (sessionId && messageCount > 0 && !pending) {
+        consolidateSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "consolidation failed during close");
+        });
+      }
       teardown();
       ActiveEngine.unregister(room).catch(() => {});
     },

package/src/cli/index.ts

@@ -433,6 +433,12 @@ switch (command) {
     process.exit(exitCode);
   }
 
+  case "backup": {
+    const { backupCommand } = await import("../commands/backup");
+    await backupCommand();
+    break;
+  }
+
   case "validate": {
     const { validateConfig } = await import("../commands/validate");
     const result = validateConfig();
@@ -444,6 +450,15 @@ switch (command) {
   case "update": {
     const { version: currentVersion } = await import("../../package.json");
     console.log(`Current: v${currentVersion}`);
+    // Auto-backup before update
+    try {
+      const { createBackup } = await import("../commands/backup");
+      console.log("Backing up...");
+      await createBackup(true);
+      console.log("✓ pre-update backup created");
+    } catch (err) {
+      console.log(`⚠ backup skipped: ${errMsg(err)}`);
+    }
     console.log("Updating...");
     const install = Bun.spawn(["npm", "i", "-g", "niahere@latest"], { stdio: ["ignore", "inherit", "inherit"] });
     const installExit = await install.exited;

package/src/commands/backup.ts

@@ -0,0 +1,146 @@
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
+import { join, basename } from "path";
+import { getNiaHome } from "../utils/paths";
+import { getConfig } from "../utils/config";
+
+const MAX_BACKUPS = 10;
+
+function getBackupDir(): string {
+  const dir = join(getNiaHome(), "backups");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function humanDate(): string {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function pruneOldBackups(dir: string): void {
+  const files = readdirSync(dir)
+    .filter((f) => f.startsWith("niahere-") && f.endsWith(".tar.gz"))
+    .map((f) => ({ name: f, mtime: statSync(join(dir, f)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  for (const file of files.slice(MAX_BACKUPS)) {
+    unlinkSync(join(dir, file.name));
+    console.log(`  pruned old backup: ${file.name}`);
+  }
+}
+
+export async function createBackup(silent = false): Promise<string> {
+  const home = getNiaHome();
+  const backupDir = getBackupDir();
+  const filename = `niahere-${humanDate()}-${Math.floor(Date.now() / 1000)}.tar.gz`;
+  const outPath = join(backupDir, filename);
+
+  // Directories/files to include (relative to home)
+  const includes: string[] = [];
+  if (existsSync(join(home, "config.yaml"))) includes.push("config.yaml");
+  if (existsSync(join(home, "self"))) includes.push("self");
+  if (existsSync(join(home, "agents"))) includes.push("agents");
+  if (existsSync(join(home, "skills"))) includes.push("skills");
+
+  // Database dump
+  const config = getConfig();
+  const dbUrl = config.database_url;
+  let dbDumped = false;
+  if (dbUrl) {
+    const dumpPath = join(home, "tmp", "db-backup.sql");
+    mkdirSync(join(home, "tmp"), { recursive: true });
+    const pg = Bun.spawn(["pg_dump", dbUrl, "-f", dumpPath], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const exitCode = await pg.exited;
+    if (exitCode === 0 && existsSync(dumpPath)) {
+      // Copy to a relative path for tar
+      const relDump = "db-backup.sql";
+      const { copyFileSync } = await import("fs");
+      copyFileSync(dumpPath, join(home, relDump));
+      includes.push(relDump);
+      dbDumped = true;
+    } else if (!silent) {
+      const stderr = await new Response(pg.stderr).text();
+      console.log(`  ⚠ db dump skipped: ${stderr.trim() || `exit ${exitCode}`}`);
+    }
+  }
+
+  if (includes.length === 0) {
+    console.log("Nothing to back up.");
+    return "";
+  }
+
+  // Create tar.gz
+  const tar = Bun.spawn(["tar", "czf", outPath, ...includes], {
+    cwd: home,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const tarExit = await tar.exited;
+  if (tarExit !== 0) {
+    const stderr = await new Response(tar.stderr).text();
+    throw new Error(`tar failed: ${stderr.trim()}`);
+  }
+
+  // Clean up temp db dump
+  if (dbDumped) {
+    try { unlinkSync(join(home, "db-backup.sql")); } catch {}
+    try { unlinkSync(join(home, "tmp", "db-backup.sql")); } catch {}
+  }
+
+  const size = statSync(outPath).size;
+  if (!silent) {
+    console.log(`✓ backup created: ${filename} (${formatSize(size)})`);
+    if (dbDumped) console.log("  includes: files + database");
+    else console.log("  includes: files only (no database)");
+  }
+
+  pruneOldBackups(backupDir);
+
+  return outPath;
+}
+
+export function listBackups(): void {
+  const dir = getBackupDir();
+  const files = readdirSync(dir)
+    .filter((f) => f.startsWith("niahere-") && f.endsWith(".tar.gz"))
+    .map((f) => {
+      const stat = statSync(join(dir, f));
+      return { name: f, size: stat.size, mtime: stat.mtimeMs };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+
+  if (files.length === 0) {
+    console.log("No backups found.");
+    return;
+  }
+
+  console.log(`${files.length} backup(s) in ${dir}:\n`);
+  for (const f of files) {
+    const date = new Date(f.mtime).toLocaleString();
+    console.log(`  ${f.name}  ${formatSize(f.size)}  ${date}`);
+  }
+}
+
+export async function backupCommand(): Promise<void> {
+  const sub = process.argv[3];
+  if (sub === "list") {
+    listBackups();
+  } else if (!sub) {
+    await createBackup();
+  } else {
+    console.log("Usage:");
+    console.log("  nia backup        — create a backup");
+    console.log("  nia backup list   — list existing backups");
+  }
+}

package/src/core/consolidator.ts

@@ -0,0 +1,138 @@
+/**
+ * Memory consolidator — "hippocampal replay" for Nia.
+ *
+ * After a chat session goes idle or a job completes, this module reviews
+ * what happened and saves memories worth keeping.
+ *
+ * This decouples memory formation from task execution: during a conversation,
+ * the agent focuses on the task. Afterward, a background pass extracts what's
+ * worth remembering — just like the brain consolidates memories during sleep.
+ *
+ * The consolidator uses the same agent loop as cron jobs — full Nia system
+ * prompt, full tool access, same runner. It's just a specialized job.
+ *
+ * Research basis:
+ * - LangChain: "background" memory formation avoids latency + competing optimization pressures
+ * - Mem0: LLM-driven extraction with ADD/UPDATE/NOOP decisions against existing memories
+ * - Cognitive science: hippocampal replay consolidates experiences after the fact, not during
+ */
+
+import { Message } from "../db/models";
+import { buildSystemPrompt } from "../chat/identity";
+import { runJobWithClaude } from "./runner";
+import { log } from "../utils/log";
+import { homedir } from "os";
+import type { SessionMessage } from "../types";
+
+/** Track sessions already consolidated to prevent double runs. */
+const consolidated = new Set<string>();
+
+/** Max messages to include in transcript (most recent). Keeps prompt size bounded. */
+const MAX_TRANSCRIPT_MESSAGES = 50;
+
+/** Rooms to skip (placeholder sessions). */
+function shouldSkip(room: string): boolean {
+  return room.includes("placeholder");
+}
+
+/** Format conversation transcript for the extraction prompt. Cap to recent messages. */
+function formatTranscript(messages: SessionMessage[]): string {
+  const recent = messages.slice(-MAX_TRANSCRIPT_MESSAGES);
+  const skipped = messages.length - recent.length;
+  const prefix = skipped > 0 ? `[...${skipped} earlier messages omitted]\n\n` : "";
+
+  return prefix + recent
+    .map((m) => `[${m.sender}] (${m.createdAt}): ${m.content.slice(0, 2000)}`)
+    .join("\n\n");
+}
+
+/** Build the extraction prompt from a conversation transcript. */
+function buildConsolidationPrompt(transcript: string, source: string): string {
+  return `Job: memory-consolidation (triggered by ${source})
+
+You just finished a session. It has gone idle.
+Your task: review the transcript below and save anything worth keeping for future sessions.
+
+## Transcript
+${transcript}
+
+## Instructions
+1. First, read your existing memories (read_memory tool) and rules (read rules.md) to avoid duplicates
+2. Review the transcript for things worth persisting. Use the RIGHT tool for each:
+
+   **Use add_memory for FACTS** (nouns — things that are true):
+   - People: names, roles, orgs, relationships
+   - Decisions: what was decided or agreed on
+   - Technical facts: system details, API quirks, config gotchas
+   - Patterns: recurring issues, user behaviors, workflow tendencies
+   - Events: travel, deadlines, incidents, milestones with dates
+
+   **Use add_rule for INSTRUCTIONS** (verbs — how to behave):
+   - User corrected your tone, format, or approach
+   - User said "from now on" / "always" / "never" / "stop doing X"
+   - User expressed a preference about how you communicate or work
+
+3. Skip anything already in existing memories or rules (no duplicates)
+4. Skip small talk, greetings, conversational filler
+5. Skip transient state ("currently working on X")
+6. Quality over quantity — saving nothing is fine if the conversation was trivial
+7. If existing memories are outdated based on new info, note what should be updated
+
+Do NOT message the user about this. Save silently and report a brief summary of what you saved.`;
+}
+
+/** Run the consolidation agent loop. */
+async function runConsolidation(transcript: string, source: string): Promise<void> {
+  const systemPrompt = buildSystemPrompt("job");
+  const jobPrompt = buildConsolidationPrompt(transcript, source);
+  const output = await runJobWithClaude(systemPrompt, jobPrompt, homedir());
+
+  if (output.error) {
+    log.error({ source, error: output.error }, "consolidator: extraction failed");
+  } else {
+    log.info({ source, resultChars: output.agentText.length }, "consolidator: done");
+  }
+}
+
+/**
+ * Consolidate a chat session's conversation into memories.
+ * Called when a chat engine goes idle or is explicitly closed.
+ */
+export async function consolidateSession(sessionId: string, room: string): Promise<void> {
+  if (shouldSkip(room)) return;
+  if (consolidated.has(sessionId)) return;
+  consolidated.add(sessionId);
+
+  try {
+    const messages = await Message.getBySession(sessionId);
+    if (messages.length < 2) return;
+
+    log.info({ sessionId, room, messageCount: messages.length }, "consolidator: extracting memories from chat");
+
+    const transcript = formatTranscript(messages);
+    await runConsolidation(transcript, `chat session idle — ${room}`);
+  } catch (err) {
+    log.error({ err, sessionId, room }, "consolidator: chat extraction failed");
+  }
+}
+
+/**
+ * Consolidate a job run's output into memories.
+ * Called after a job completes in the runner.
+ */
+export async function consolidateJobRun(jobName: string, jobPrompt: string, result: string): Promise<void> {
+  // Skip if the job itself is the consolidator (prevent infinite loop)
+  if (jobName === "memory-consolidation") return;
+
+  const transcript = `[job-prompt]: ${jobPrompt}\n\n[job-result]: ${result}`;
+
+  // Skip trivial results
+  if (result.length < 50) return;
+
+  try {
+    log.info({ jobName, resultChars: result.length }, "consolidator: extracting memories from job");
+    await runConsolidation(transcript, `job run — ${jobName}`);
+  } catch (err) {
+    log.error({ err, jobName }, "consolidator: job extraction failed");
+  }
+}

package/src/core/runner.ts

@@ -257,6 +257,13 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     };
     writeState(freshState);
 
+    // Memory consolidation — review what the job learned (fire-and-forget)
+    if (ok && result.result) {
+      import("./consolidator").then(({ consolidateJobRun }) => {
+        consolidateJobRun(job.name, jobPrompt, result.result).catch(() => {});
+      }).catch(() => {});
+    }
+
     return result;
   } catch (err) {
     const duration_ms = Math.round(performance.now() - startMs);

package/src/db/migrations/008_message_delivery_status.ts

@@ -0,0 +1,10 @@
+import type postgres from "postgres";
+
+export const name = "008_message_delivery_status";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`
+    ALTER TABLE messages
+    ADD COLUMN IF NOT EXISTS delivery_status TEXT DEFAULT 'sent'
+  `;
+}

package/src/db/models/message.ts

@@ -1,12 +1,45 @@
 import { getSql } from "../connection";
 import type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, SessionMessage } from "../../types";
 
-export async function save(params: SaveMessageParams): Promise<void> {
+export type DeliveryStatus = "pending" | "sent" | "failed";
+
+export async function save(params: SaveMessageParams & { deliveryStatus?: DeliveryStatus }): Promise<number> {
   const sql = getSql();
-  await sql`
-    INSERT INTO messages (session_id, room, sender, content, is_from_agent)
-    VALUES (${params.sessionId}, ${params.room}, ${params.sender}, ${params.content}, ${params.isFromAgent})
+  const status = params.deliveryStatus || "sent";
+  const rows = await sql`
+    INSERT INTO messages (session_id, room, sender, content, is_from_agent, delivery_status)
+    VALUES (${params.sessionId}, ${params.room}, ${params.sender}, ${params.content}, ${params.isFromAgent}, ${status})
+    RETURNING id
   `;
+  return rows[0].id;
+}
+
+export async function updateDeliveryStatus(id: number, status: DeliveryStatus): Promise<void> {
+  const sql = getSql();
+  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[]> {

package/src/types/engine.ts

@@ -2,6 +2,8 @@ export interface SendResult {
   result: string;
   costUsd: number;
   turns: number;
+  /** DB message ID for delivery status tracking (only set for agent replies) */
+  messageId?: number;
 }
 
 export type StreamCallback = (textSoFar: string) => void;