niahere 0.2.46 → 0.2.48

package/package.json

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

package/src/chat/engine.ts

@@ -332,22 +332,42 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
           }
 
           if (message.type === "result" && pending) {
+            const msg = message as any;
             if (!message.is_error) {
-              const resultText = (message as any).result as string;
-              const costUsd = (message as any).total_cost_usd as number;
-              const turns = (message as any).num_turns as number;
+              const resultText = msg.result as string;
+              const costUsd = msg.total_cost_usd as number;
+              const turns = msg.num_turns as number;
+
+              const metadata: Record<string, unknown> = {
+                cost_usd: costUsd,
+                turns,
+                duration_ms: msg.duration_ms,
+                duration_api_ms: msg.duration_api_ms,
+                stop_reason: msg.stop_reason,
+                session_id: msg.session_id,
+                subtype: msg.subtype,
+                usage: msg.usage,
+                model_usage: msg.modelUsage,
+              };
 
               let messageId: number | undefined;
               if (sessionId && resultText) {
-                messageId = await Message.save({
+                const saveParams = {
                   sessionId,
                   room,
                   sender: "nia",
                   content: resultText,
                   isFromAgent: true,
-                  deliveryStatus: "pending",
-                });
+                  deliveryStatus: "pending" as const,
+                  metadata,
+                };
+                try {
+                  messageId = await Message.save(saveParams);
+                } catch {
+                  messageId = await Message.save({ ...saveParams, metadata: undefined });
+                }
                 await Session.touch(sessionId);
+                await Session.accumulateMetadata(sessionId, { ...metadata, channel }).catch(() => {});
               }
 
               await ActiveEngine.unregister(room);
@@ -356,7 +376,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
               pending = null;
               resetIdleTimer();
             } else {
-              const errors = (message as any).errors;
+              const errors = msg.errors;
               const errorText = `[error] ${errors?.join(", ") || "unknown error"}`;
               await ActiveEngine.unregister(room);
               clearLongRunningTimer();

package/src/core/consolidator.ts

@@ -18,10 +18,8 @@
  */
 
 import { Message } from "../db/models";
-import { buildSystemPrompt } from "../chat/identity";
-import { runJobWithClaude } from "./runner";
+import { runTask } from "./runner";
 import { log } from "../utils/log";
-import { homedir } from "os";
 import type { SessionMessage } from "../types";
 
 /** Track sessions already consolidated to prevent double runs. */
@@ -83,15 +81,10 @@ Do NOT message the user about this. Save silently and report a brief summary of
 
 /** 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");
-  }
+  await runTask({
+    name: "consolidator",
+    prompt: buildConsolidationPrompt(transcript, source),
+  });
 }
 
 /**

package/src/core/runner.ts

@@ -9,6 +9,9 @@ import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
 import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
+import { getMcpServers } from "../mcp";
+import { ActiveEngine } from "../db/models";
+import { log } from "../utils/log";
 
 export type ActivityCallback = (line: string) => void;
 
@@ -87,14 +90,21 @@ export async function runJobWithClaude(
     };
   }
 
+  const options: Record<string, unknown> = {
+    systemPrompt,
+    cwd,
+    permissionMode: "bypassPermissions",
+    sessionId,
+  };
+
+  const mcpServers = getMcpServers();
+  if (mcpServers) {
+    options.mcpServers = mcpServers;
+  }
+
   const handle = query({
     prompt: singleMessage() as any,
-    options: {
-      systemPrompt,
-      cwd,
-      permissionMode: "bypassPermissions",
-      sessionId,
-    } as any,
+    options: options as any,
   });
 
   let agentText = "";
@@ -178,6 +188,40 @@ export async function runJobWithClaude(
   return { agentText, sessionId: actualSessionId };
 }
 
+// ---------------------------------------------------------------------------
+// Background task runner — tracked one-shot agent with full Nia personality
+// ---------------------------------------------------------------------------
+
+export interface TaskOptions {
+  /** Task name — used for ActiveEngine tracking as _system/{name}. */
+  name: string;
+  /** The prompt/instruction for the task. */
+  prompt: string;
+  /** System prompt override. Defaults to buildSystemPrompt("job"). */
+  systemPrompt?: string;
+}
+
+/**
+ * Run a background agent task with ActiveEngine tracking and MCP tools.
+ * Use for consolidator, summarizer, and any future background work.
+ */
+export async function runTask(opts: TaskOptions): Promise<RunnerOutput> {
+  const room = `_system/${opts.name}`;
+  await ActiveEngine.register(room, "system").catch(() => {});
+  try {
+    const systemPrompt = opts.systemPrompt || buildSystemPrompt("job");
+    const output = await runJobWithClaude(systemPrompt, opts.prompt, homedir());
+    if (output.error) {
+      log.error({ task: opts.name, error: output.error }, "task failed");
+    } else {
+      log.info({ task: opts.name, resultChars: output.agentText.length }, "task completed");
+    }
+    return output;
+  } finally {
+    await ActiveEngine.unregister(room).catch(() => {});
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

package/src/core/summarizer.ts

@@ -11,10 +11,8 @@
  */
 
 import { Message, Session } from "../db/models";
-import { buildSystemPrompt } from "../chat/identity";
-import { runJobWithClaude } from "./runner";
+import { runTask } from "./runner";
 import { log } from "../utils/log";
-import { homedir } from "os";
 import type { SessionMessage } from "../types";
 
 /** Track sessions already summarized to prevent double runs. */
@@ -46,10 +44,9 @@ export async function summarizeSession(sessionId: string, room: string): Promise
 
     log.info({ sessionId, room, messageCount: messages.length }, "summarizer: generating session summary");
 
-    const systemPrompt = buildSystemPrompt("job");
     const transcript = formatTranscript(messages);
 
-    const jobPrompt = `Job: session-summary (triggered by session idle in ${room})
+    const prompt = `Job: session-summary (triggered by session idle in ${room})
 
 Generate a brief session summary. This will be shown to your future self at the start of the next session for continuity.
 
@@ -64,7 +61,7 @@ Write a 2-4 sentence summary covering:
 
 Keep it concise — a handoff note, not a report. Output ONLY the summary text.`;
 
-    const output = await runJobWithClaude(systemPrompt, jobPrompt, homedir());
+    const output = await runTask({ name: "summarizer", prompt });
 
     if (output.error) {
       log.error({ sessionId, room, error: output.error }, "summarizer: failed");

package/src/db/migrations/010_message_metadata.ts

@@ -0,0 +1,10 @@
+import type postgres from "postgres";
+
+export const name = "010_message_metadata";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`
+    ALTER TABLE messages
+    ADD COLUMN IF NOT EXISTS metadata JSONB
+  `;
+}

package/src/db/migrations/011_session_metadata.ts

@@ -0,0 +1,7 @@
+import type postgres from "postgres";
+
+export const name = "011_session_metadata";
+
+export async function up(sql: postgres.Sql): Promise<void> {
+  await sql`ALTER TABLE sessions ADD COLUMN IF NOT EXISTS metadata JSONB`;
+}

package/src/db/models/message.ts

@@ -3,12 +3,13 @@ import type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, Session
 
 export type DeliveryStatus = "pending" | "sent" | "failed";
 
-export async function save(params: SaveMessageParams & { deliveryStatus?: DeliveryStatus }): 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;
   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})
+    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})
     RETURNING id
   `;
   return rows[0].id;

package/src/db/models/session.ts

@@ -113,6 +113,44 @@ export async function getRecentSummaries(room: string, limit = 3): Promise<Array
   }));
 }
 
+export async function accumulateMetadata(id: string, resultMeta: Record<string, unknown>): Promise<void> {
+  const sql = getSql();
+  const rows = await sql`SELECT metadata FROM sessions WHERE id = ${id}`;
+  const existing = (rows[0]?.metadata as Record<string, unknown>) || {};
+
+  const modelUsage = resultMeta.model_usage as Record<string, Record<string, number>> | undefined;
+  const modelsUsed = new Set<string>((existing.models_used as string[]) || []);
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheCreationTokens = 0;
+  if (modelUsage) {
+    for (const [model, usage] of Object.entries(modelUsage)) {
+      modelsUsed.add(model);
+      inputTokens += usage.inputTokens || 0;
+      outputTokens += usage.outputTokens || 0;
+      cacheReadTokens += usage.cacheReadInputTokens || 0;
+      cacheCreationTokens += usage.cacheCreationInputTokens || 0;
+    }
+  }
+
+  const updated: Record<string, unknown> = {
+    total_cost_usd: ((existing.total_cost_usd as number) || 0) + ((resultMeta.cost_usd as number) || 0),
+    total_turns: ((existing.total_turns as number) || 0) + ((resultMeta.turns as number) || 0),
+    total_duration_ms: ((existing.total_duration_ms as number) || 0) + ((resultMeta.duration_ms as number) || 0),
+    total_duration_api_ms: ((existing.total_duration_api_ms as number) || 0) + ((resultMeta.duration_api_ms as number) || 0),
+    total_input_tokens: ((existing.total_input_tokens as number) || 0) + inputTokens,
+    total_output_tokens: ((existing.total_output_tokens as number) || 0) + outputTokens,
+    total_cache_read_tokens: ((existing.total_cache_read_tokens as number) || 0) + cacheReadTokens,
+    total_cache_creation_tokens: ((existing.total_cache_creation_tokens as number) || 0) + cacheCreationTokens,
+    message_count: ((existing.message_count as number) || 0) + 1,
+    models_used: [...modelsUsed],
+    channel: existing.channel || resultMeta.channel,
+  };
+
+  await sql`UPDATE sessions SET metadata = ${JSON.stringify(updated)} WHERE id = ${id}`;
+}
+
 export async function getLatestRoomIndex(prefix: string): Promise<number> {
   const sql = getSql();
   const rows = await sql`