niahere 0.2.47 → 0.2.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.47",
+  "version": "0.2.49",
   "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);
+                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/cli/index.ts

@@ -276,11 +276,11 @@ switch (command) {
 
   case "chat": {
     const chatArgs = process.argv.slice(3);
-    const mode = (chatArgs.includes("--new") || chatArgs.includes("-n"))
-      ? "new" as const
+    const mode = (chatArgs.includes("--continue") || chatArgs.includes("-c"))
+      ? "continue" as const
       : (chatArgs.includes("--resume") || chatArgs.includes("-r"))
         ? "pick" as const
-        : "continue" as const;
+        : "new" as const;
     const chIdx = chatArgs.indexOf("--channel");
     const simChannel = chIdx !== -1 && chatArgs[chIdx + 1] ? chatArgs[chIdx + 1] : undefined;
     await startRepl(mode, simChannel);

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,58 @@ 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 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 delta = JSON.stringify({
+    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,
+    total_duration_api_ms: (resultMeta.duration_api_ms as number) || 0,
+    total_input_tokens: inputTokens,
+    total_output_tokens: outputTokens,
+    total_cache_read_tokens: cacheReadTokens,
+    total_cache_creation_tokens: cacheCreationTokens,
+    message_count: 1,
+    models_used: newModels,
+    channel: resultMeta.channel || null,
+  });
+
+  // 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,
+      'message_count',                COALESCE((metadata->>'message_count')::int, 0)                 + 1,
+      'models_used',                  COALESCE(metadata->'models_used', '[]'::jsonb) || ${JSON.stringify(newModels)}::jsonb,
+      'channel',                      COALESCE(metadata->>'channel', ${(resultMeta.channel as string) || null})
+    )
+    WHERE id = ${id}
+  `;
+}
+
 export async function getLatestRoomIndex(prefix: string): Promise<number> {
   const sql = getSql();
   const rows = await sql`