@bongos/core 1.19.316 → 1.19.318

package/tests/session_cost_row_raise.mjs

@@ -0,0 +1,139 @@
+// tests/session_cost_row_raise.mjs — task 1003217 (real DB).
+//
+// BUG A: a long session's cost row froze at the FIRST ship. `session_records`
+// is upserted on every ship, so a twelve-task session has a digest from its
+// first ship; the reconciler priced that partial digest ~15 min later, and
+// logCost's `ON CONFLICT DO NOTHING` then silently dropped every later, larger
+// figure. Prod evidence: a 9.3-hour session billed at its first 56 minutes;
+// across four audited sessions the ledger held 14%, 14%, 16% and 54% of real
+// spend.
+//
+// What this pins, against real SQL because every claim here IS the SQL:
+//   • a never-priced session still gets its row (the original task-1366 job),
+//   • a session whose digest GREW is revisited and its row RAISED,
+//   • the raise is monotonic — a lower figure never lowers a paid row,
+//   • the sweep CONVERGES: once settled, a second run books nothing,
+//   • totalUsd bills only the INCREMENT on a raise, never the whole row again,
+//   • a client-split session (source_ref || ':sub') is still left alone.
+//
+// Real-DB integration test: self-skips without a reachable Postgres.
+// Run:  DATABASE_URL=postgres:///bongos_test node --test tests/session_cost_row_raise.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+
+const probe = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+let live = true;
+try { await probe.query('SELECT 1 FROM cost_log LIMIT 1'); } catch (e) {
+  console.log(`session_cost_row_raise.mjs SKIPPED — no reachable Postgres with the GDS schema (${e.code || e.message}).`);
+  live = false;
+}
+await probe.end().catch(() => {});
+
+const B = 90000411;                       // fixture builder
+const S1 = 'sess-raise-0000000000000001'; // grows across ships
+const S2 = 'sess-raise-0000000000000002'; // client-split, must be untouched
+const M = 1_000_000;
+
+// opus-5 cache_read is $0.50/M, so cache_read tokens make a clean, exact figure.
+const digest = (cacheReadM) => ({ 'claude-opus-5': { input: 0, output: 0, cache_read: cacheReadM * M, cache_creation: 0 } });
+
+if (live) {
+  const cost = require('../modules/economy/cost.js');
+  const pool = cost.pool || new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+  const q = (sql, p) => pool.query(sql, p).then((r) => r.rows);
+
+  const seedDigest = async (sid, cacheReadM, uploadedAgoMin) => q(
+    `INSERT INTO session_records (session_id, builder_id, model_usage, uploaded_at)
+     VALUES ($1,$2,$3::jsonb, now() - ($4 || ' minutes')::interval)
+     ON CONFLICT (session_id) DO UPDATE SET
+       model_usage = EXCLUDED.model_usage, uploaded_at = EXCLUDED.uploaded_at`,
+    [sid, B, JSON.stringify(digest(cacheReadM)), String(uploadedAgoMin)]
+  );
+  const row = async (sid) => (await q(
+    `SELECT amount_usd, cache_read_usd, description, recorded_at FROM cost_log
+      WHERE source='session:interactive' AND source_ref=$1`, [sid]))[0];
+  const rowCount = async (sid) => Number((await q(
+    `SELECT count(*) n FROM cost_log WHERE source_ref LIKE $1 || '%'`, [sid]))[0].n);
+  // Backdate the priced row, modelling production: the sweep prices an early
+  // partial digest, and the session keeps shipping for hours afterwards. The
+  // revisit predicate is `cost_log.recorded_at < session_records.uploaded_at`,
+  // so the row must genuinely predate the digest growth for a raise to be due.
+  const backdateRow = async (sid, minsAgo) => q(
+    `UPDATE cost_log SET recorded_at = now() - ($2 || ' minutes')::interval
+      WHERE source='session:interactive' AND source_ref=$1`, [sid, String(minsAgo)]);
+
+  const cleanup = async () => {
+    await q(`DELETE FROM cost_log WHERE source_ref LIKE 'sess-raise-%'`);
+    await q(`DELETE FROM session_records WHERE session_id LIKE 'sess-raise-%'`);
+    await q(`DELETE FROM builders WHERE id=$1`, [B]);
+  };
+
+  await cleanup();
+  await q(`INSERT INTO builders (id, github_id, github_login, display_name, rank)
+           VALUES ($1, 990000411, 'fixture-raise','fixture-raise','xenos')
+           ON CONFLICT (id) DO NOTHING`, [B]);
+
+  test('1003217 a never-priced session gets its row (the original task-1366 job)', async () => {
+    await seedDigest(S1, 10, 30); // 10M cache_read = $5.00
+    const r = await cost.reconcileSessionCosts({ olderThanMinutes: 15 });
+    assert.ok(r.scanned >= 1, 'the unpriced session is scanned');
+    const got = await row(S1);
+    assert.equal(Number(got.amount_usd), 5, 'priced at $5.00');
+    assert.match(got.description, /client cost-hook did not post/, 'first write keeps its provenance wording');
+  });
+
+  test('1003217 the row is RAISED when the digest grows (the frozen-row bug)', async () => {
+    // Priced an hour ago, off the first ship's partial digest...
+    await backdateRow(S1, 60);
+    // ...then the session shipped more tasks: the digest is replaced with the
+    // fuller transcript figure and uploaded_at moves forward.
+    await seedDigest(S1, 100, 20); // 100M cache_read = $50.00
+    const r = await cost.reconcileSessionCosts({ olderThanMinutes: 15 });
+    assert.equal(r.raised, 1, 'exactly one row raised');
+    const got = await row(S1);
+    assert.equal(Number(got.amount_usd), 50, 'row caught up from $5 to $50');
+    assert.equal(Number(got.cache_read_usd), 50, 'the tier split is rewritten too, not left stale');
+    assert.match(got.description, /raised from \$5\.0000 as the session grew/, 'the raise is legible in the ledger');
+    // Only the increment is billed as this sweep's spend.
+    assert.ok(Math.abs(r.totalUsd - 45) < 1e-6, `totalUsd should be the $45 increment, got ${r.totalUsd}`);
+    assert.equal(await rowCount(S1), 1, 'still ONE row — a raise must never fork a second');
+  });
+
+  test('1003217 the sweep converges: a settled session books nothing on the next run', async () => {
+    const r = await cost.reconcileSessionCosts({ olderThanMinutes: 15 });
+    assert.equal(r.raised, 0, 'nothing left to raise');
+    assert.equal(r.reconciled, 0, 'nothing left to insert');
+    assert.equal(Number((await row(S1)).amount_usd), 50, 'the row is unchanged');
+  });
+
+  test('1003217 the raise is MONOTONIC — a smaller figure never lowers a paid row', async () => {
+    // This is the "do not re-price history" guarantee: after the dedup fix
+    // (bug B) a re-priced old session computes LOWER, and llm-pricing.js is
+    // explicit that a paid row records what was charged. It must hold.
+    await backdateRow(S1, 60);
+    await seedDigest(S1, 4, 20); // would be $2.00 — far below the $50 on file
+    const r = await cost.reconcileSessionCosts({ olderThanMinutes: 15 });
+    assert.equal(r.raised, 0, 'a downward move is not a raise');
+    assert.equal(Number((await row(S1)).amount_usd), 50, 'the row held at $50');
+    assert.ok(Math.abs(r.totalUsd) < 1e-9, 'and nothing was billed');
+  });
+
+  test('1003217 a client-split session (:sub) is still left entirely alone', async () => {
+    await seedDigest(S2, 10, 30);
+    await q(`INSERT INTO cost_log (amount_usd, category, source, source_ref, builder_id)
+             VALUES (1.23,'api','session:subagent',$1 || ':sub',$2)`, [S2, B]);
+    const before = await rowCount(S2);
+    await cost.reconcileSessionCosts({ olderThanMinutes: 15 });
+    assert.equal(await rowCount(S2), before, 'no interactive row invented alongside the client split');
+    assert.equal(await row(S2), undefined, 'specifically: no session:interactive row for it');
+  });
+
+  test('cleanup', async () => {
+    await cleanup();
+    if (!cost.pool) await pool.end().catch(() => {});
+  });
+}

package/tests/session_records.mjs

@@ -405,3 +405,75 @@ test('a failed/empty subagent spawn digests to 0 tokens despite 1 assistant turn
 console.log('');
 console.log(`Session-records (6D.1) tests: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);
+
+// ---------- task 1003217: one API call is many transcript lines ----------
+//
+// Claude Code writes a separate line per content block of one assistant message
+// (thinking / text / tool_use) and repeats the SAME message.usage on each. The
+// digest must price the call ONCE. Measured 2.22x inflation on real transcripts
+// before this fix.
+function splitCallFixture() {
+  const usage = {
+    input_tokens: 2,
+    output_tokens: 799,
+    cache_read_input_tokens: 63182,
+    cache_creation_input_tokens: 3227,
+  };
+  const mk = (content) => ({
+    type: 'assistant',
+    timestamp: '2026-08-21T19:23:47.000Z',
+    message: { id: 'msg_01SPLIT', model: 'claude-opus-5', usage, content },
+  });
+  return [
+    mk([{ type: 'thinking', thinking: 'weighing it up' }]),
+    mk([{ type: 'text', text: 'Here is the plan.' }]),
+    mk([{ type: 'tool_use', name: 'Bash', input: { command: 'ls' } }]),
+  ];
+}
+
+test('1003217 buildSessionDigest prices one split assistant message ONCE, not per line', () => {
+  const d = buildSessionDigest(splitCallFixture());
+  // 3 transcript lines, 1 API call.
+  assert.equal(d.metrics.assistant_turns, 3, 'assistant_turns stays the LINE count for existing consumers');
+  assert.equal(d.metrics.api_calls, 1, 'api_calls is the honest round-trip count');
+  assert.equal(d.metrics.tokens.output, 799, 'output counted once, not 3x');
+  assert.equal(d.metrics.tokens.cache_read, 63182, 'cache_read counted once, not 3x');
+  assert.equal(d.metrics.tokens.cache_creation, 3227);
+  assert.equal(d.metrics.tokens.input, 2);
+  assert.equal(d.totalTokens, 2 + 799 + 63182 + 3227);
+  assert.deepEqual(d.metrics.model_usage['claude-opus-5'], {
+    input: 2, output: 799, cache_read: 63182, cache_creation: 3227,
+  }, 'model_usage — the cost-plus reward basis (ADR 0054) — must not be inflated');
+  // The tool_use on the third line is still seen.
+  assert.equal(d.metrics.tool_use_count, 1);
+});
+
+test('1003217 the detail rows still sum to the true usage (repeats zeroed + flagged)', () => {
+  const d = buildSessionDigest(splitCallFixture());
+  const asst = d.detail.filter((r) => r.role === 'assistant');
+  assert.equal(asst.length, 3, 'every line keeps its detail row');
+  const sum = (k) => asst.reduce((a, r) => a + (r[k] || 0), 0);
+  assert.equal(sum('cache_read'), 63182, 'summing detail must not double-count');
+  assert.equal(sum('out'), 799);
+  assert.equal(asst.filter((r) => r.dup === 1).length, 2, 'the two repeat lines are flagged dup');
+  assert.equal(asst[0].dup, undefined, 'the first line of the call is not a dup');
+});
+
+test('1003217 distinct message ids are still counted separately', () => {
+  const usage = { input_tokens: 0, output_tokens: 10, cache_read_input_tokens: 100, cache_creation_input_tokens: 0 };
+  const mk = (id) => ({
+    type: 'assistant',
+    timestamp: '2026-08-21T19:23:47.000Z',
+    message: { id, model: 'claude-opus-5', usage, content: [{ type: 'text', text: 'x' }] },
+  });
+  const d = buildSessionDigest([mk('msg_A'), mk('msg_B'), mk('msg_C')]);
+  assert.equal(d.metrics.api_calls, 3);
+  assert.equal(d.metrics.tokens.cache_read, 300, 'three real calls = three times the usage');
+});
+
+test('1003217 a transcript with no message.id degrades to the old per-line behaviour', () => {
+  const d = buildSessionDigest(fixture()); // fixture() messages carry no id
+  assert.equal(d.metrics.tokens.input, 300, 'unchanged from the pre-fix expectation');
+  assert.equal(d.metrics.tokens.output, 130);
+  assert.equal(d.metrics.api_calls, 2, 'with no id to dedup on, every line is its own call');
+});