niahere 0.5.0 → 0.5.2

package/src/cli/update.ts

@@ -0,0 +1,79 @@
+import { isRunning, readPid } from "../utils/pid";
+import { errMsg } from "../utils/errors";
+import { guardActiveEngines, parseGuardFlags, withDefaultWait } from "../core/engine-guard";
+import { startDaemon, stopDaemon } from "../core/daemon";
+
+/** `nia update` — upgrade the global install, then restart if the daemon is up. */
+export async function updateCommand(argv: string[]): Promise<void> {
+  const guard = withDefaultWait(parseGuardFlags(argv), 1);
+  const { version: currentVersion } = await import("../../package.json");
+  console.log(`Current: v${currentVersion}`);
+
+  // Never upgrade out from under a live turn.
+  if (isRunning() && !(await guardActiveEngines("update", guard))) process.exit(1);
+
+  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"] });
+  if ((await install.exited) !== 0) {
+    console.error("Update failed.");
+    process.exit(1);
+  }
+
+  const check = Bun.spawn(["npm", "view", "niahere", "version"], { stdout: "pipe", stderr: "pipe" });
+  const newVersion = (await new Response(check.stdout).text()).trim();
+  await check.exited;
+
+  if (newVersion === currentVersion) {
+    console.log("Already on latest.");
+    return;
+  }
+
+  console.log(`Updated: v${currentVersion} → v${newVersion}`);
+  if (!isRunning()) return;
+
+  console.log("Restarting daemon...");
+  const { isServiceInstalled, restartService } = await import("../commands/service");
+  if (isServiceInstalled()) {
+    await restartService({ force: guard.force });
+  } else {
+    stopDaemon({ force: guard.force });
+    startDaemon();
+  }
+  console.log("Restarted.");
+}
+
+/** `nia channels <on|off> [name]` — toggle channels and nudge a running daemon. */
+export async function channelsToggleCommand(sub: string, target?: string): Promise<void> {
+  const { updateRawConfig } = await import("../utils/config");
+  const SUPPORTED = new Set(["telegram", "slack", "phone", "sms", "whatsapp"]);
+  const enabled = sub === "on";
+
+  if (target) {
+    if (!SUPPORTED.has(target)) {
+      console.error(`Usage: nia channels <on|off> [${[...SUPPORTED].join("|")}]`);
+      process.exit(1);
+    }
+    updateRawConfig({ channels: { ...(enabled ? { enabled: true } : {}), [target]: { enabled } } });
+  } else {
+    updateRawConfig({ channels: { enabled } });
+  }
+
+  const what = target ?? "channels";
+  const state = enabled ? "enabled" : "disabled";
+  const pid = readPid();
+  if (pid && isRunning()) {
+    process.kill(pid, "SIGHUP");
+    console.log(`${what} ${state}`);
+  } else {
+    console.log(`${what} ${state} — start nia to apply`);
+  }
+}

package/src/commands/backup.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
 import { join, basename } from "path";
 import { getNiaHome } from "../utils/paths";
 import { getConfig } from "../utils/config";
@@ -79,7 +79,6 @@ export async function createBackup(silent = false): Promise<string> {
     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;

package/src/commands/init.ts

@@ -1,5 +1,5 @@
 import * as readline from "readline";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { homedir } from "os";
 import { getNiaHome, getPaths } from "../utils/paths";
@@ -436,7 +436,6 @@ export async function runInit(): Promise<void> {
           }
         } else if (hasDefaultReference) {
           // No description — copy defaults
-          const { copyFileSync } = await import("fs");
           copyFileSync(`${SKILL_ASSETS_DIR}/nia-reference.webp`, `${imagesDir}/reference.webp`);
           console.log(`  \u2713 copied default reference image`);
           if (existsSync(`${SKILL_ASSETS_DIR}/nia-profile.webp`)) {

package/src/core/alive.ts

@@ -1,4 +1,7 @@
 import { log } from "../utils/log";
+import { homedir } from "os";
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { errMsg } from "../utils/errors";
 import { getConfig } from "../utils/config";
 import { getSql, closeDb } from "../db/connection";
 import { reconcileChannels } from "../channels";
@@ -23,7 +26,6 @@ async function recoverPostgres(): Promise<boolean> {
   log.info("alive: postgres not ready, attempting deterministic recovery");
 
   // Find and remove stale postmaster.pid
-  const { existsSync, unlinkSync, readFileSync } = await import("fs");
   for (const dir of PG_DATA_DIRS) {
     const pidFile = `${dir}/postmaster.pid`;
     if (!existsSync(pidFile)) continue;
@@ -126,7 +128,6 @@ async function notifyUser(message: string): Promise<void> {
 async function runRecoveryAgent(failures: Check[]): Promise<{ recovered: boolean; report: string }> {
   try {
     const { runOneShot } = await import("./runner");
-    const { homedir } = await import("os");
 
     const failureSummary = failures.map((f) => `- ${f.name}: ${f.detail}`).join("\n");
 
@@ -160,7 +161,7 @@ async function runRecoveryAgent(failures: Check[]): Promise<{ recovered: boolean
   } catch (err) {
     return {
       recovered: false,
-      report: `Recovery agent failed to run: ${err instanceof Error ? err.message : String(err)}`,
+      report: `Recovery agent failed to run: ${errMsg(err)}`,
     };
   }
 }

package/src/core/consolidator.ts

@@ -10,36 +10,69 @@
  * See AGENTS.md > "Two-stage memory" for the full architecture.
  */
 
-import { Message } from "../db/models";
+import { Message, Session } from "../db/models";
 import { runTask } from "./runner";
 import { log } from "../utils/log";
 import type { SessionMessage } from "../types";
 
-/** Bounded dedup: sessionId → message count at last consolidation. Prevents re-processing
- *  the same messages while allowing re-consolidation when new turns arrive. */
-const processedCounts = new Map<string, number>();
 const inFlight = new Set<string>();
-const MAX_TRACKED = 500;
 
-/** Max messages to include in transcript (most recent). Keeps prompt size bounded. */
+/** Max messages in one transcript. Keeps the prompt bounded. */
 const MAX_TRANSCRIPT_MESSAGES = 50;
 
+/** New turns required before a session already consolidated is looked at again.
+ *  Without it, a long-running room re-sends its whole window on every message. */
+export const MIN_NEW_MESSAGES = 6;
+
+/** Prior turns replayed alongside new ones, so a learning that spans the
+ *  boundary is not cut in half. */
+export const CONTEXT_TAIL = 5;
+
+export interface ConsolidationPlan {
+  run: boolean;
+  /** Index into the session's messages to start the transcript from. */
+  from: number;
+}
+
+/**
+ * Decide whether a session is worth (re-)reading and over what window.
+ *
+ * A session is always read once — a correction can be two turns, and skipping
+ * short sessions starves the pipeline. After that it takes a real batch of new
+ * turns to justify another pass, and only the new tail is re-read.
+ */
+export function planConsolidation(total: number, consolidated: number): ConsolidationPlan {
+  const floor = Math.max(0, total - MAX_TRANSCRIPT_MESSAGES);
+
+  if (consolidated <= 0) {
+    return { run: total >= 2, from: floor };
+  }
+  if (total - consolidated < MIN_NEW_MESSAGES) {
+    return { run: false, from: floor };
+  }
+  return { run: true, from: Math.max(floor, consolidated - CONTEXT_TAIL) };
+}
+
 /** 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");
+/** Format the transcript window for the extraction prompt. */
+function formatTranscript(messages: SessionMessage[], from: number, consolidated: number): string {
+  const window = messages.slice(from);
+  const prefix = from > 0 ? `[...${from} earlier messages already consolidated, omitted]\n\n` : "";
+  const seen = Math.max(0, consolidated - from);
+  const marker = seen > 0 ? `\n\n--- everything below is NEW since the last pass ---\n` : "";
+
+  const lines = window.map(
+    (m, i) => `${i === seen && marker ? marker : ""}[${m.sender}] (${m.createdAt}): ${m.content.slice(0, 2000)}`,
+  );
+  return prefix + lines.join("\n\n");
 }
 
 /** Build the consolidation prompt from a conversation transcript. */
-function buildConsolidationPrompt(transcript: string, source: string): string {
+export function buildConsolidationPrompt(transcript: string, source: string): string {
   const today = new Date().toISOString().slice(0, 10);
   return `Job: memory-consolidation (triggered by ${source})
 
@@ -91,11 +124,27 @@ stop here and do not write anything.
    (Includes: "we're using X not Y", config changes, deployment patterns)
 4. What did the user explicitly ask to be remembered?
 
-Trivial small talk, greetings, and pure status updates are NOT answers.
-But corrections made DURING task execution ("no, check DynamoDB not S3"),
+Corrections made DURING task execution ("no, check DynamoDB not S3"),
 architecture learned while debugging ("ah, this service talks to X via Y"),
 and workflow patterns revealed by how the user works — these ARE answers.
-The bar is: would a fresh Nia session benefit from knowing this?
+
+**The bar is durability: would this still be true and useful in 30 days?**
+"Would a fresh session benefit" is too weak — it admits anything mildly
+relevant. A fact that expires with the week is noise once it expires.
+
+Never stage any of these, however interesting they seemed in the moment:
+
+- **Transient state** — what a service was doing today, a current error, a
+  job's latest output, "X is down". True this hour, misleading next month.
+- **One-off events** — a single incident, a one-time request, "we deployed
+  at 3pm". A pattern needs repetition; one occurrence is an anecdote.
+- **Derivable facts** — anything already in the repo, config, git history,
+  or \`nia status\`. If a future session can look it up, it does not need
+  remembering.
+- **Task chatter** — what was done this session, progress reports, what to
+  do next. That belongs in the work, not in who the user is.
+- **Restatements** — a rewording of something in \`memory.md\` or \`rules.md\`.
+  Reinforce the existing entry instead (Step 3.2).
 
 ## Step 3 — Update staging.md
 
@@ -128,6 +177,8 @@ For each substantive answer:
 - Do NOT message the user.
 - If nothing qualifies, do nothing. But don't be so conservative that the
   pipeline starves — if you're skipping every session, your bar is too high.
+  Most sessions should yield zero or one candidate. Several is suspicious;
+  re-check them against the exclusion list before writing.
 
 Report a one-line summary of what you did: "staged N new / reinforced M /
 skipped (trivial session)". No preamble.`;
@@ -155,26 +206,22 @@ export async function consolidateSession(sessionId: string, room: string): Promi
 
   try {
     const messages = await Message.getBySession(sessionId);
-    if (messages.length < 2) return;
-
-    // Skip if already processed this exact message count
-    if (processedCounts.get(sessionId) === messages.length) return;
+    const consolidated = await Session.getConsolidatedCount(sessionId);
+    const plan = planConsolidation(messages.length, consolidated);
+    if (!plan.run) return;
 
     inFlight.add(sessionId);
 
-    log.info({ sessionId, room, messageCount: messages.length }, "consolidator: extracting memories from chat");
+    log.info(
+      { sessionId, room, messageCount: messages.length, consolidated, from: plan.from },
+      "consolidator: extracting memories from chat",
+    );
 
-    const transcript = formatTranscript(messages);
+    const transcript = formatTranscript(messages, plan.from, consolidated);
     await runConsolidation(transcript, `chat session idle — ${room}`);
 
-    // Mark as processed only on success
-    processedCounts.set(sessionId, messages.length);
-
-    // Evict oldest entries when over cap
-    if (processedCounts.size > MAX_TRACKED) {
-      const firstKey = processedCounts.keys().next().value;
-      if (firstKey) processedCounts.delete(firstKey);
-    }
+    // Advance the watermark only on success.
+    await Session.setConsolidatedCount(sessionId, messages.length);
   } catch (err) {
     log.error({ err, sessionId, room }, "consolidator: chat extraction failed");
     throw err;

package/src/core/daemon.ts

@@ -4,6 +4,7 @@ import { fileURLToPath } from "url";
 import { getPaths } from "../utils/paths";
 import { getConfig, resetConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { asError, ignore } from "../utils/errors";
 import { isRunning, readPid, removePid, writePid } from "../utils/pid";
 import { ActiveEngine, Job } from "../db/models";
 import { runMigrations } from "../db/migrate";
@@ -192,7 +193,7 @@ export async function runDaemon(): Promise<void> {
     process.exit(1);
   });
   process.on("unhandledRejection", (reason) => {
-    const err = reason instanceof Error ? reason : new Error(String(reason));
+    const err = asError(reason);
     log.fatal({ err }, "unhandled rejection — cleaning up");
     removePid();
     process.exit(1);
@@ -353,7 +354,7 @@ export async function runDaemon(): Promise<void> {
     log.info("received SIGHUP, reloading config");
     resetConfig();
     await reconcileChannels();
-    await recomputeAllNextRuns().catch(() => {});
+    await ignore(recomputeAllNextRuns(), "recompute next runs after SIGHUP");
   });
 
   let shuttingDown = false;

package/src/core/finalizer.ts

@@ -12,6 +12,7 @@ import { consolidateSession } from "./consolidator";
 import { summarizeSession } from "./summarizer";
 import { loadConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { ignore } from "../utils/errors";
 
 type FinalizationTask = "consolidate" | "summarize";
 
@@ -132,11 +133,14 @@ async function processOne(sessionId: string, room: string, messageCount: number)
       log.error({ sessionId, room, messageCount, errors }, "finalizer: completed with task failures");
     }
   } catch (err) {
-    await sql`
-      UPDATE finalization_requests
-      SET status = 'failed', updated_at = NOW()
-      WHERE id = ${requestId}
-    `.catch(() => {});
+    await ignore(
+      sql`
+        UPDATE finalization_requests
+        SET status = 'failed', updated_at = NOW()
+        WHERE id = ${requestId}
+      `,
+      "mark finalization request failed",
+    );
 
     log.error({ err, sessionId, room }, "finalizer: processing failed");
   }

package/src/core/runner.ts

@@ -13,6 +13,7 @@ import { buildJobPrompt } from "./job-prompt";
 import { getMcpServers, type McpSourceContext } from "../mcp";
 import { ActiveEngine } from "../db/models";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { registerActiveHandle, unregisterActiveHandle } from "./active-handles";
 import { resolveChain, ChainCursor, describeEntry, type ChainEntry, type AgentSession, type AgentSessionContext, type FailoverScope } from "../agent";
 
@@ -105,7 +106,7 @@ async function runEntry(
     const session = await entry.backend.openSession({ ...sessionCtx, model: entry.model });
     return await consumeBackendRun(session, prompt, onActivity, activeRoom);
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message = errMsg(err);
     log.warn({ entry: describeEntry(entry), err: message }, "backend failed to start");
     return { agentText: "", sessionId: "", error: message, failover: "provider" };
   }
@@ -178,7 +179,7 @@ export interface TaskOptions {
  */
 export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
   const room = `_system/${opts.name}`;
-  await ActiveEngine.register(room, "system").catch(() => {});
+  await ignore(ActiveEngine.register(room, "system"), "register system active-engine");
   try {
     const systemPrompt = opts.systemPrompt || buildSystemPrompt("job");
     const output = await runOneShot({ systemPrompt, prompt: opts.prompt, cwd: homedir(), activeRoom: room });
@@ -189,7 +190,7 @@ export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
     }
     return output;
   } finally {
-    await ActiveEngine.unregister(room).catch(() => {});
+    await ignore(ActiveEngine.unregister(room), "unregister active-engine");
   }
 }
 
@@ -207,7 +208,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
   const state: Record<string, JobState> = { ...readState() };
   state[job.name] = { lastRun: timestamp, status: "running", duration_ms: 0 };
   writeState(state);
-  await ActiveEngine.register(room, "job").catch(() => {});
+  await ignore(ActiveEngine.register(room, "job"), "register job active-engine");
 
   try {
     let cwd = homedir();
@@ -300,7 +301,7 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     return result;
   } catch (err) {
     const duration_ms = Math.round(performance.now() - startMs);
-    const errorMsg = err instanceof Error ? err.message : String(err);
+    const errorMsg = errMsg(err);
 
     const result: JobResult = {
       job: job.name,
@@ -332,6 +333,6 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
 
     return result;
   } finally {
-    await ActiveEngine.unregister(room).catch(() => {});
+    await ignore(ActiveEngine.unregister(room), "unregister active-engine");
   }
 }

package/src/core/scheduler.ts

@@ -85,8 +85,16 @@ async function tick(): Promise<void> {
     try {
       nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
     } catch (err) {
-      log.error({ err, job: job.name, schedule: job.schedule }, "scheduler: invalid schedule, disabling job");
-      await Job.update(job.name, { status: "disabled" }).catch(() => {});
+      log.error({ err, job: job.name, schedule: job.schedule }, "scheduler: invalid schedule");
+      try {
+        await Job.update(job.name, { status: "disabled" });
+        log.info({ job: job.name }, "scheduler: disabled job with invalid schedule");
+      } catch (updateErr) {
+        log.error(
+          { err: updateErr, job: job.name },
+          "scheduler: could not disable job with invalid schedule — it will keep failing every tick",
+        );
+      }
       continue;
     }
     await Job.markRun(job.name, nextRun).catch((err) => {
@@ -95,8 +103,15 @@ async function tick(): Promise<void> {
 
     // Auto-disable one-shot jobs after execution
     if (job.scheduleType === "once") {
-      await Job.update(job.name, { status: "disabled" }).catch(() => {});
-      log.info({ job: job.name }, "scheduler: one-shot job completed, auto-disabled");
+      try {
+        await Job.update(job.name, { status: "disabled" });
+        log.info({ job: job.name }, "scheduler: one-shot job completed, auto-disabled");
+      } catch (err) {
+        log.error(
+          { err, job: job.name },
+          "scheduler: one-shot job completed but could not be disabled — it will run again",
+        );
+      }
     }
   }
 }

package/src/core/skills.ts

@@ -63,10 +63,6 @@ export function scanSkills(): SkillInfo[] {
   return skills;
 }
 
-export function getSkillNames(): string[] {
-  return scanSkills().map((s) => s.name);
-}
-
 export function getSkillsSummary(): string {
   const skills = scanSkills();
   if (skills.length === 0) return "";

package/src/db/migrations/017_sessions_consolidated_count.ts

@@ -0,0 +1,9 @@
+import type postgres from "postgres";
+
+export const name = "017_sessions_consolidated_count";
+
+/** Watermark for the memory consolidator. Lives in the DB rather than in
+ *  memory so a daemon restart does not re-consolidate every session again. */
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`ALTER TABLE sessions ADD COLUMN IF NOT EXISTS consolidated_count INTEGER NOT NULL DEFAULT 0`;
+}

package/src/db/models/active_engine.ts

@@ -26,13 +26,6 @@ export async function unregister(room: string): Promise<void> {
   await sql`DELETE FROM active_engines WHERE room = ${room}`;
 }
 
-export async function clearStale(
-  maxAgeMs: number = 5 * 60 * 1000,
-): Promise<void> {
-  const sql = getSql();
-  await sql`DELETE FROM active_engines WHERE last_ping < NOW() - ${maxAgeMs / 1000}::int * interval '1 second'`;
-}
-
 export async function clearAll(): Promise<void> {
   const sql = getSql();
   await sql`DELETE FROM active_engines`;

package/src/db/models/job.ts

@@ -1,4 +1,5 @@
 import { getSql } from "../connection";
+import { errMsg } from "../../utils/errors";
 import { CronExpressionParser } from "cron-parser";
 import { parseDuration } from "../../utils/duration";
 import { computeInitialNextRun } from "../../utils/schedule";
@@ -13,14 +14,14 @@ function validateSchedule(schedule: string, scheduleType: ScheduleType): void {
       try {
         CronExpressionParser.parse(schedule);
       } catch (err) {
-        throw new Error(`Invalid cron expression "${schedule}": ${err instanceof Error ? err.message : err}`);
+        throw new Error(`Invalid cron expression "${schedule}": ${errMsg(err)}`);
       }
       break;
     case "interval":
       try {
         parseDuration(schedule);
       } catch (err) {
-        throw new Error(`Invalid interval "${schedule}": ${err instanceof Error ? err.message : err}`);
+        throw new Error(`Invalid interval "${schedule}": ${errMsg(err)}`);
       }
       break;
     case "once": {

package/src/db/models/message.ts

@@ -46,6 +46,16 @@ export async function getRecent(limit = 20, room?: string): Promise<RecentMessag
   }));
 }
 
+/** When the room last saw any message. Null for a room with no history. */
+export async function getLastAt(room: string): Promise<Date | null> {
+  const sql = getSql();
+  const rows = await sql`
+    SELECT created_at FROM messages WHERE room = ${room}
+    ORDER BY created_at DESC LIMIT 1
+  `;
+  return rows.length > 0 ? new Date(rows[0].created_at) : null;
+}
+
 export async function search(query: string, limit = 20, room?: string): Promise<SearchResult[]> {
   const sql = getSql();
   const pattern = `%${query}%`;

package/src/db/models/session.ts

@@ -122,24 +122,62 @@ export async function getRecentSummaries(
   }));
 }
 
+export interface UsageTotals {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheCreationTokens: number;
+  models: string[];
+  providers: string[];
+}
+
+const num = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+const str = (v: unknown): string | null => (typeof v === "string" && v ? v : null);
+
+/**
+ * Fold a result's per-model usage into totals. `provider` matters because a
+ * chain that fails over makes the model name alone ambiguous about who served
+ * the turn.
+ */
+export function summarizeModelUsage(modelUsage: unknown): UsageTotals {
+  const totals: UsageTotals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    models: [],
+    providers: [],
+  };
+  if (!modelUsage || typeof modelUsage !== "object") return totals;
+
+  const models = new Set<string>();
+  const providers = new Set<string>();
+  for (const [key, raw] of Object.entries(modelUsage as Record<string, unknown>)) {
+    const usage = (raw && typeof raw === "object" ? raw : {}) as Record<string, unknown>;
+    models.add(str(usage.canonicalModel) ?? key);
+    const provider = str(usage.provider);
+    if (provider) providers.add(provider);
+    totals.inputTokens += num(usage.inputTokens);
+    totals.outputTokens += num(usage.outputTokens);
+    totals.cacheReadTokens += num(usage.cacheReadInputTokens);
+    totals.cacheCreationTokens += num(usage.cacheCreationInputTokens);
+  }
+  totals.models = [...models];
+  totals.providers = [...providers];
+  return totals;
+}
+
 export async function accumulateMetadata(id: string, resultMeta: Record<string, unknown>): Promise<void> {
   const sql = getSql();
 
-  const modelUsage = resultMeta.model_usage as Record<string, Record<string, number>> | undefined;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cacheReadTokens = 0;
-  let cacheCreationTokens = 0;
-  const newModels: string[] = [];
-  if (modelUsage) {
-    for (const [model, usage] of Object.entries(modelUsage)) {
-      newModels.push(model);
-      inputTokens += usage.inputTokens || 0;
-      outputTokens += usage.outputTokens || 0;
-      cacheReadTokens += usage.cacheReadInputTokens || 0;
-      cacheCreationTokens += usage.cacheCreationInputTokens || 0;
-    }
-  }
+  const {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    models: newModels,
+    providers: newProviders,
+  } = summarizeModelUsage(resultMeta.model_usage);
 
   // Bind deltas as jsonb via sql.json — pre-stringifying would store a
   // double-encoded string scalar, making every `->>` extraction return NULL
@@ -155,9 +193,11 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     total_cache_creation_tokens: cacheCreationTokens,
     message_count: 1,
     models_used: newModels,
+    providers_used: newProviders,
     channel: (resultMeta.channel as string) || null,
   });
   const modelsDelta = sql.json(newModels);
+  const providersDelta = sql.json(newProviders);
 
   // Atomic accumulate — no read-then-write race
   await sql`
@@ -173,6 +213,8 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
       'message_count',                COALESCE((metadata->>'message_count')::int, 0)                 + 1,
       'models_used',                  (SELECT COALESCE(jsonb_agg(DISTINCT e), '[]'::jsonb)
                                          FROM jsonb_array_elements(COALESCE(metadata->'models_used', '[]'::jsonb) || ${modelsDelta}) AS e),
+      'providers_used',               (SELECT COALESCE(jsonb_agg(DISTINCT e), '[]'::jsonb)
+                                         FROM jsonb_array_elements(COALESCE(metadata->'providers_used', '[]'::jsonb) || ${providersDelta}) AS e),
       'channel',                      COALESCE(metadata->>'channel', ${(resultMeta.channel as string) || null})
     )
     WHERE id = ${id}
@@ -192,3 +234,15 @@ export async function getLatestRoomIndex(prefix: string): Promise<number> {
   }
   return max;
 }
+
+/** How many messages of this session the consolidator has already read. */
+export async function getConsolidatedCount(sessionId: string): Promise<number> {
+  const sql = getSql();
+  const rows = await sql`SELECT consolidated_count FROM sessions WHERE id = ${sessionId}`;
+  return rows.length > 0 ? Number(rows[0].consolidated_count ?? 0) : 0;
+}
+
+export async function setConsolidatedCount(sessionId: string, count: number): Promise<void> {
+  const sql = getSql();
+  await sql`UPDATE sessions SET consolidated_count = ${count} WHERE id = ${sessionId}`;
+}

package/src/mcp/tools/misc.ts

@@ -1,4 +1,5 @@
 import { appendFileSync } from "fs";
+import { errMsg } from "../../utils/errors";
 import { join } from "path";
 import { getPaths } from "../../utils/paths";
 import { scanAgents } from "../../core/agents";
@@ -58,6 +59,6 @@ export async function placeCall(args: {
     });
     return `Call placed. callSid=${result.callSid} status=${result.status}. Transcript will land in messages once the call completes.`;
   } catch (err) {
-    return `place_call failed: ${err instanceof Error ? err.message : String(err)}`;
+    return `place_call failed: ${errMsg(err)}`;
   }
 }