niahere 0.2.48 → 0.2.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "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

@@ -367,7 +367,7 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                   messageId = await Message.save({ ...saveParams, metadata: undefined });
                 }
                 await Session.touch(sessionId);
-                await Session.accumulateMetadata(sessionId, { ...metadata, channel }).catch(() => {});
+                Session.accumulateMetadata(sessionId, { ...metadata, channel }).catch(() => {});
               }
 
               await ActiveEngine.unregister(room);

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/core/scheduler.ts

@@ -79,10 +79,10 @@ async function tick(): Promise<void> {
 
   for (const job of dueJobs) {
     if (!job.always && !isWithinActiveHours()) {
-      const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
-      if (nextRun) {
-        await Job.markRun(job.name, nextRun).catch(() => {});
-      }
+      try {
+        const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
+        if (nextRun) await Job.markRun(job.name, nextRun).catch(() => {});
+      } catch {}
       log.info({ job: job.name }, "scheduler: skipping — outside active hours");
       continue;
     }
@@ -95,7 +95,14 @@ async function tick(): Promise<void> {
       log.error({ err, job: job.name }, "scheduler: job failed");
     });
 
-    const nextRun = computeNextRun(job.scheduleType, job.schedule, config.timezone, new Date());
+    let nextRun: Date | null = null;
+    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, { enabled: false }).catch(() => {});
+      continue;
+    }
     await Job.markRun(job.name, nextRun).catch((err) => {
       log.error({ err, job: job.name }, "scheduler: failed to update next_run_at");
     });

package/src/db/models/session.ts

@@ -115,18 +115,16 @@ 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;
+  const newModels: string[] = [];
   if (modelUsage) {
     for (const [model, usage] of Object.entries(modelUsage)) {
-      modelsUsed.add(model);
+      newModels.push(model);
       inputTokens += usage.inputTokens || 0;
       outputTokens += usage.outputTokens || 0;
       cacheReadTokens += usage.cacheReadInputTokens || 0;
@@ -134,21 +132,37 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
     }
   }
 
-  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,
-  };
+  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,
+  });
 
-  await sql`UPDATE sessions SET metadata = ${JSON.stringify(updated)} WHERE id = ${id}`;
+  // 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> {