niahere 0.5.2 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/agent/backends/claude-normalize.ts

@@ -17,6 +17,21 @@ const DEAD_TURNS: Record<string, FailoverScope | undefined> = {
   turn_setup_failed: undefined,
 };
 
+/**
+ * Stamp the chain's provider over the SDK's own, which names the deployment
+ * target (firstParty/bedrock/vertex) — a different axis from which backend ran
+ * the turn, and the one `providers_used` has to answer.
+ */
+function attribute(modelUsage: unknown): Record<string, unknown> | undefined {
+  if (!modelUsage || typeof modelUsage !== "object") return undefined;
+  return Object.fromEntries(
+    Object.entries(modelUsage as Record<string, unknown>).map(([model, usage]) => [
+      model,
+      { ...(usage as object), provider: "claude" },
+    ]),
+  );
+}
+
 /**
  * Pure reducer: Claude Agent SDK messages → normalized `AgentEvent`s.
  *
@@ -151,7 +166,7 @@ export class SdkNormalizer implements Normalizer {
           session_id: msg.session_id,
           subtype: msg.subtype,
           usage: msg.usage,
-          model_usage: msg.modelUsage,
+          model_usage: attribute(msg.modelUsage),
         },
       };
     }

package/src/agent/backends/codex-normalize.ts

@@ -40,7 +40,11 @@ export class CodexNormalizer implements Normalizer {
       case "turn.failed":
         return this.fail(typeof e.error?.message === "string" ? e.error.message : "");
       case "turn.completed": {
-        const input = e.usage?.input_tokens ?? 0;
+        // Codex counts like OpenAI: `input_tokens` is the whole prompt with
+        // `cached_input_tokens` a slice of it. Claude reports the two as
+        // siblings and one accumulator sums both, so the slice comes out here.
+        const cacheRead = e.usage?.cached_input_tokens ?? 0;
+        const input = Math.max(0, (e.usage?.input_tokens ?? 0) - cacheRead);
         const output = e.usage?.output_tokens ?? 0;
         return [
           {
@@ -50,13 +54,16 @@ export class CodexNormalizer implements Normalizer {
             backendSessionId: this.threadId,
             // Same shape the Claude path emits, so one accumulator serves both
             // and a failed-over turn is attributable to the provider that ran it.
+            // No cost: codex reports none, and an invented zero would read as a
+            // free turn.
             metadata: {
               model_usage: {
                 [this.model || "default"]: {
                   provider: "codex",
                   inputTokens: input,
                   outputTokens: output,
-                  cacheReadInputTokens: e.usage?.cached_input_tokens ?? 0,
+                  cacheReadInputTokens: cacheRead,
+                  cacheCreationInputTokens: e.usage?.cache_write_input_tokens ?? 0,
                 },
               },
             },

package/src/chat/engine.ts

@@ -323,7 +323,11 @@ export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine>
                   };
                   try {
                     messageId = await Message.save(saveParams);
-                  } catch {
+                  } catch (e) {
+                    // Saving the reply matters more than saving its usage, but a
+                    // silent drop cost eight days of the ledger before anyone
+                    // looked.
+                    log.error({ room, error: errMsg(e) }, "dropping turn metadata; message saved without it");
                     messageId = await Message.save({ ...saveParams, metadata: undefined });
                   }
                   await Session.touch(sessionId);

package/src/cli/index.ts

@@ -203,6 +203,12 @@ switch (command) {
     break;
   }
 
+  case "usage": {
+    const { usageCommand } = await import("./usage");
+    await usageCommand(process.argv.slice(3));
+    break;
+  }
+
   case "seed": {
     await import("../db/seed");
     break;
@@ -337,6 +343,7 @@ Daemon:
   model [name]                    Show or set global Claude model
   health                          Check daemon, db, channels, config
   logs [-f] [--channel ch]        Daemon logs (filter by channel)
+  usage [--days N --by dim --room R --json]  Tokens and cost per day/model/provider/room
 
 Chat:
   chat [-c] [-r] [--employee|--agent|--job name]  Interactive chat

package/src/cli/usage.ts

@@ -0,0 +1,189 @@
+import { withDb } from "../db/with-db";
+import { queryUsage, type UsageRow } from "../db/models/usage";
+import { getConfig } from "../utils/config";
+import { BOLD, DIM, RESET, fail } from "../utils/cli";
+import { errMsg } from "../utils/errors";
+
+export type Dimension = "day" | "model" | "provider" | "room";
+
+const DIMENSIONS: Dimension[] = ["day", "model", "provider", "room"];
+
+export interface UsageOptions {
+  days: number;
+  by: Dimension;
+  room?: string;
+  json: boolean;
+}
+
+export interface UsageBucket {
+  key: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  /** null when nothing in the bucket carried a cost. */
+  costUsd: number | null;
+  turns: number;
+  unpricedTurns: number;
+}
+
+export function parseUsageArgs(argv: string[]): UsageOptions {
+  const opts: UsageOptions = { days: 7, by: "day", json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    const value = argv[i + 1];
+    if (arg === "--json") {
+      opts.json = true;
+    } else if (arg === "--days" && value) {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isInteger(parsed) && parsed > 0) opts.days = parsed;
+      i += 1;
+    } else if (arg === "--by" && value) {
+      if (!DIMENSIONS.includes(value as Dimension)) throw new Error(`--by must be one of: ${DIMENSIONS.join(", ")}`);
+      opts.by = value as Dimension;
+      i += 1;
+    } else if (arg === "--room" && value) {
+      opts.room = value;
+      i += 1;
+    }
+  }
+  return opts;
+}
+
+export function rollup(rows: UsageRow[], by: Dimension): UsageBucket[] {
+  const byKey = new Map<string, UsageBucket>();
+  for (const row of rows) {
+    const key = row[by];
+    const seen = byKey.get(key);
+    if (!seen) {
+      byKey.set(key, {
+        key,
+        inputTokens: row.inputTokens,
+        outputTokens: row.outputTokens,
+        cacheReadTokens: row.cacheReadTokens,
+        cacheWriteTokens: row.cacheWriteTokens,
+        costUsd: row.costUsd,
+        turns: row.turns,
+        unpricedTurns: row.unpricedTurns,
+      });
+      continue;
+    }
+    seen.inputTokens += row.inputTokens;
+    seen.outputTokens += row.outputTokens;
+    seen.cacheReadTokens += row.cacheReadTokens;
+    seen.cacheWriteTokens += row.cacheWriteTokens;
+    seen.turns += row.turns;
+    seen.unpricedTurns += row.unpricedTurns;
+    // A known cost survives an unknown one beside it; only an all-unknown
+    // bucket reports nothing.
+    seen.costUsd = seen.costUsd === null && row.costUsd === null ? null : (seen.costUsd ?? 0) + (row.costUsd ?? 0);
+  }
+
+  const buckets = [...byKey.values()];
+  return by === "day"
+    ? buckets.sort((a, b) => a.key.localeCompare(b.key))
+    : buckets.sort((a, b) => (b.costUsd ?? 0) - (a.costUsd ?? 0) || b.turns - a.turns);
+}
+
+export function compactTokens(n: number): string {
+  if (n >= 1_000_000) return `${round(n / 1_000_000)}M`;
+  if (n >= 1_000) return `${round(n / 1_000)}K`;
+  return String(n);
+}
+
+function round(n: number): string {
+  return n.toFixed(1).replace(/\.0$/, "");
+}
+
+export function formatCost(cost: number | null): string {
+  if (cost === null) return "—";
+  // Sub-cent turns are common; rounding them to $0.00 hides real spend.
+  return cost > 0 && cost < 0.01 ? `$${cost.toFixed(4)}` : `$${cost.toFixed(2)}`;
+}
+
+const COLUMNS: [string, (b: UsageBucket) => string][] = [
+  ["Turns", (b) => String(b.turns)],
+  ["Input", (b) => compactTokens(b.inputTokens)],
+  ["Output", (b) => compactTokens(b.outputTokens)],
+  ["Cache rd", (b) => compactTokens(b.cacheReadTokens)],
+  ["Cache wr", (b) => compactTokens(b.cacheWriteTokens)],
+  ["Cost", (b) => formatCost(b.costUsd)],
+];
+
+export function renderTable(buckets: UsageBucket[], label: string): string[] {
+  const header = [label, ...COLUMNS.map(([name]) => name)];
+  const body = buckets.map((b) => [b.key, ...COLUMNS.map(([, read]) => read(b))]);
+  const total = buckets.reduce<UsageBucket>((sum, b) => {
+    sum.inputTokens += b.inputTokens;
+    sum.outputTokens += b.outputTokens;
+    sum.cacheReadTokens += b.cacheReadTokens;
+    sum.cacheWriteTokens += b.cacheWriteTokens;
+    sum.turns += b.turns;
+    sum.unpricedTurns += b.unpricedTurns;
+    sum.costUsd = sum.costUsd === null && b.costUsd === null ? null : (sum.costUsd ?? 0) + (b.costUsd ?? 0);
+    return sum;
+  }, emptyBucket("Total"));
+
+  const rows = [header, ...body, [total.key, ...COLUMNS.map(([, read]) => read(total))]];
+  const widths = header.map((_, col) => Math.max(...rows.map((r) => r[col]!.length)));
+  const line = (cells: string[]) =>
+    cells.map((cell, col) => (col === 0 ? cell.padEnd(widths[col]!) : cell.padStart(widths[col]!))).join("  ");
+
+  const out = [`${BOLD}${line(header)}${RESET}`, ...body.map(line), `${BOLD}${line(rows.at(-1)!)}${RESET}`];
+  if (total.unpricedTurns > 0) {
+    out.push(`${DIM}${total.unpricedTurns} of ${total.turns} turns report no cost (codex bills no per-token price)${RESET}`);
+  }
+  return out;
+}
+
+function emptyBucket(key: string): UsageBucket {
+  return {
+    key,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costUsd: null,
+    turns: 0,
+    unpricedTurns: 0,
+  };
+}
+
+export async function usageCommand(argv: string[]): Promise<void> {
+  let opts: UsageOptions;
+  try {
+    opts = parseUsageArgs(argv);
+  } catch (e) {
+    fail(errMsg(e));
+  }
+  const since = new Date(Date.now() - opts.days * 24 * 60 * 60 * 1000);
+  const timezone = getConfig().timezone || "UTC";
+
+  const rows = await withDb(() =>
+    queryUsage({ since, ...(opts.room !== undefined ? { room: opts.room } : {}), timezone }),
+  );
+
+  if (opts.json) {
+    console.log(JSON.stringify({ since: since.toISOString(), timezone, rows }, null, 2));
+    return;
+  }
+
+  if (rows.length === 0) {
+    console.log(`No recorded usage in the last ${opts.days} days${opts.room ? ` for ${opts.room}` : ""}.`);
+    return;
+  }
+
+  const scope = opts.room ? ` · ${opts.room}` : "";
+  console.log(`\nUsage — last ${opts.days} days${scope} (${timezone})\n`);
+  for (const line of renderTable(rollup(rows, opts.by), title(opts.by))) console.log(line);
+
+  if (opts.by === "day") {
+    console.log("\nBy model");
+    for (const line of renderTable(rollup(rows, "model"), "Model")) console.log(`  ${line}`);
+  }
+  console.log();
+}
+
+function title(by: Dimension): string {
+  return by === "day" ? "Day" : by[0]!.toUpperCase() + by.slice(1);
+}

package/src/core/runner.ts

@@ -125,15 +125,30 @@ export async function runJobAcrossChain(
 ): Promise<RunnerOutput> {
   const cursor = new ChainCursor(chain);
   let output: RunnerOutput = { agentText: "", sessionId: "", error: "no model configured" };
+  const abandoned: string[] = [];
+
+  // The last entry's message alone hides why the chain started walking, which
+  // is usually the more useful half.
+  const withTrail = (out: RunnerOutput): RunnerOutput =>
+    out.error && abandoned.length > 0 ? { ...out, error: `${out.error} (after ${abandoned.join("; ")})` } : out;
 
   for (let entry = cursor.current; entry; ) {
     output = await runEntry(entry, sessionCtx, jobPrompt, onActivity, activeRoom);
-    if (!output.failover) return output;
+    if (!output.failover) return withTrail(output);
 
     const from = describeEntry(entry);
+    if (output.error) abandoned.push(`${from}: ${output.error}`);
     entry = cursor.advance(output.failover);
-    if (entry) log.warn({ from, to: describeEntry(entry), scope: output.failover }, "failing over to next model");
+    if (entry) {
+      log.warn(
+        { from, to: describeEntry(entry), scope: output.failover, err: output.error, terminal_reason: output.terminalReason },
+        "failing over to next model",
+      );
+    }
   }
+
+  // The chain ran out: the final entry's own failure is already the last trail
+  // entry, so reporting it twice adds nothing.
   return output;
 }
 

package/src/db/models/session.ts

@@ -182,8 +182,14 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
   // Bind deltas as jsonb via sql.json — pre-stringifying would store a
   // double-encoded string scalar, making every `->>` extraction return NULL
   // and silently zeroing all accumulated totals.
+  // Codex reports tokens but no cost. Folding that in as $0 would make a
+  // session that failed over look cheaper than one that never left Claude, so
+  // the unknown is counted rather than absorbed.
+  const priced = typeof resultMeta.cost_usd === "number";
+
   const delta = sql.json({
     total_cost_usd: (resultMeta.cost_usd as number) || 0,
+    unpriced_turns: priced ? 0 : 1,
     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,
@@ -203,6 +209,7 @@ export async function accumulateMetadata(id: string, resultMeta: Record<string,
   await sql`
     UPDATE sessions SET metadata = jsonb_build_object(
       'total_cost_usd',              COALESCE((metadata->>'total_cost_usd')::real, 0)              + (${delta}->>'total_cost_usd')::real,
+      'unpriced_turns',               COALESCE((metadata->>'unpriced_turns')::int, 0)               + (${delta}->>'unpriced_turns')::int,
       'total_turns',                  COALESCE((metadata->>'total_turns')::int, 0)                  + (${delta}->>'total_turns')::int,
       'total_duration_ms',            COALESCE((metadata->>'total_duration_ms')::real, 0)            + (${delta}->>'total_duration_ms')::real,
       'total_duration_api_ms',        COALESCE((metadata->>'total_duration_api_ms')::real, 0)        + (${delta}->>'total_duration_api_ms')::real,