@bongos/core 1.19.443 → 1.19.445

package/tests/credit_grant.mjs

@@ -588,6 +588,242 @@ await test('cost-plus-only cascade: a 0 per-task credit → idea-promotion slice
   assert.equal(client.queries.length, 0, 'no lineage lookup, no bonus INSERT when the base credit is 0');
 });
 
+// =========================================================================
+// (7) task 1003435 — a PARALLEL session (one claim, several subagents).
+//
+// The cost ledger has always billed a session's subagents subtree in its own
+// `session:subagent` cost_log row, but model_usage — the reward's only input —
+// was built from ONE file, the interactive transcript. So a builder who followed
+// CLAUDE.md's "delegate freely" moved most of a session's real spend into a
+// bucket the reward could not see, and the two ledgers described different
+// sessions.
+//
+// The acceptance test is that RECONCILIATION: what the reward prices must equal
+// what the ledger bills, within independent-rounding epsilon. It runs both real
+// pricing paths over the same on-disk fixture rather than asserting a hand-typed
+// number on either side, so a change to one that is not made to the other reds.
+// =========================================================================
+
+const fs = require('node:fs');
+const os = require('node:os');
+const nodePath = require('node:path');
+const { priceTranscript, priceSubagents, buildCostRows } = require('../scripts/gds/session-cost.js');
+const { buildSessionDigest } = require('../scripts/gds/session-digest-build.js');
+const { foldSubagentUsage } = require('../scripts/gds/ship-session-upload.js');
+const { priceModelUsage } = require('../src/bongos/llm-pricing.js');
+
+const PARALLEL_SID = 'sess-parallel';
+
+// One assistant transcript line. `id` is the API call's identity — two lines
+// sharing one are ONE call, which is what makes the dedup assertion below real.
+function asstLine(id, model, usage) {
+  return JSON.stringify({
+    type: 'assistant',
+    timestamp: '2026-08-30T00:00:00.000Z',
+    message: { id, model, usage, content: [{ type: 'text', text: 'work' }] },
+  });
+}
+function userLine(text) {
+  return JSON.stringify({
+    type: 'user',
+    timestamp: '2026-08-30T00:00:00.000Z',
+    message: { role: 'user', content: text },
+  });
+}
+function parseJsonlText(raw) {
+  return raw.split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+}
+
+// A session that spawned three subagents, one of them a grader. Mirrors the real
+// on-disk layout: the interactive transcript is a FILE, and the subagents live in
+// a sibling DIRECTORY named for the session id.
+function makeParallelFixture() {
+  const dir = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'otb-parallel-'));
+  const mainPath = nodePath.join(dir, `${PARALLEL_SID}.jsonl`);
+  // opus: 150k in / 30k out / 1.5M read / 40k write = $0.75+$0.75+$0.75+$0.25 = $2.50.
+  // m1 is written twice (one API call, two content blocks) — priced ONCE.
+  const dup = asstLine('m1', 'claude-opus-4-8', {
+    input_tokens: 100_000, output_tokens: 20_000,
+    cache_read_input_tokens: 1_000_000, cache_creation_input_tokens: 40_000,
+  });
+  fs.writeFileSync(mainPath, [
+    userLine('ship task 1003435'),
+    dup,
+    dup,
+    asstLine('m2', 'claude-opus-4-8', {
+      input_tokens: 50_000, output_tokens: 10_000,
+      cache_read_input_tokens: 500_000, cache_creation_input_tokens: 0,
+    }),
+  ].join('\n'));
+
+  const subagents = nodePath.join(dir, PARALLEL_SID, 'subagents');
+  const nested = nodePath.join(subagents, 'nested');
+  fs.mkdirSync(nested, { recursive: true });
+  // opus subagent: 200k in / 40k out / 2M read = $1.00+$1.00+$1.00 = $3.00
+  fs.writeFileSync(nodePath.join(subagents, 'agent-a.jsonl'), [
+    userLine('audit the pricing path'),
+    asstLine('a1', 'claude-opus-4-8', {
+      input_tokens: 200_000, output_tokens: 40_000, cache_read_input_tokens: 2_000_000,
+    }),
+  ].join('\n'));
+  // sonnet subagent, one level deeper — the walk is recursive:
+  // 100k in / 20k out / 1M read = $0.20+$0.20+$0.20 = $0.60
+  fs.writeFileSync(nodePath.join(nested, 'agent-b.jsonl'), [
+    userLine('read the ledger rows'),
+    asstLine('b1', 'claude-sonnet-5', {
+      input_tokens: 100_000, output_tokens: 20_000, cache_read_input_tokens: 1_000_000,
+    }),
+  ].join('\n'));
+  // A GRADER worker nested in the subagents dir. Its $5.00 is already captured via
+  // the worker envelope, so pricing it here would double-count (ADR 0028).
+  fs.writeFileSync(nodePath.join(nested, 'grader-worker.jsonl'), [
+    userLine('You are the **Hacker** — a specialist adversarial subagent. Find the holes.'),
+    asstLine('g1', 'claude-opus-4-8', { input_tokens: 1_000_000 }),
+  ].join('\n'));
+
+  return { dir, mainPath, sessionDir: nodePath.join(dir, PARALLEL_SID) };
+}
+
+const fixture = makeParallelFixture();
+const INTERACTIVE_USD = 2.50;
+const SUBAGENT_USD = 3.60;
+const SESSION_USD = INTERACTIVE_USD + SUBAGENT_USD; // $6.10
+// Each cost_log row is rounded to 4dp independently and priceModelUsage rounds
+// its own total, so the two sides may disagree by a rounding step per row.
+const EPSILON = 0.0002;
+
+// The digest the ship uploads for this session, subagents folded in.
+function parallelDigest() {
+  const digest = buildSessionDigest(parseJsonlText(fs.readFileSync(fixture.mainPath, 'utf8')));
+  foldSubagentUsage(digest, fixture.mainPath, PARALLEL_SID);
+  return digest;
+}
+
+await test('1003435 the cost ledger bills interactive + subagent, grader excluded', () => {
+  const inter = priceTranscript(fixture.mainPath);
+  const sub = priceSubagents(fixture.sessionDir);
+  assert.equal(Math.round(inter.total * 100) / 100, INTERACTIVE_USD, 'm1 priced once, not twice');
+  assert.equal(Math.round(sub.subagentTotal * 100) / 100, SUBAGENT_USD);
+  assert.equal(sub.subagentFiles, 2);
+  assert.equal(sub.graderSkipped, 1, 'the grader worker is skipped by signature');
+  const built = buildCostRows({ sessionId: PARALLEL_SID, inter, sub });
+  assert.equal(built.rows.length, 2, 'one :interactive row + one :subagent row');
+  assert.equal(Math.round(built.rowsTotal * 100) / 100, SESSION_USD);
+});
+
+await test('1003435 model_usage now carries the subagents subtree, grader excluded', () => {
+  const digest = parallelDigest();
+  const models = Object.keys(digest.metrics.model_usage).sort();
+  assert.deepEqual(models, ['claude-opus-4-8', 'claude-sonnet-5'],
+    'the sonnet subagent reached model_usage, which only the fold can do');
+  assert.equal(digest.metrics.subagent_files, 2);
+  assert.equal(digest.metrics.subagent_grader_skipped, 1);
+  // The grader's 1M opus input tokens must be in NEITHER ledger.
+  assert.equal(digest.metrics.model_usage['claude-opus-4-8'].input, 350_000,
+    '150k interactive + 200k subagent — the grader\'s 1M is not counted');
+});
+
+await test('1003435 detail + total_tokens stay the INTERACTIVE thread\'s record', () => {
+  const interactiveOnly = buildSessionDigest(
+    parseJsonlText(fs.readFileSync(fixture.mainPath, 'utf8'))
+  );
+  const digest = parallelDigest();
+  // The fold is model_usage ONLY: detail and the turn/token metrics feed the BFG
+  // corpus + inefficiency evaluator, which reason about ONE agent's turn-by-turn
+  // behaviour. Splicing N subagent transcripts into that would distort the very
+  // signal they measure, so the subagent_* counters carry the difference instead.
+  assert.equal(digest.detail.length, interactiveOnly.detail.length);
+  assert.equal(digest.totalTokens, interactiveOnly.totalTokens);
+  assert.equal(digest.metrics.assistant_turns, interactiveOnly.metrics.assistant_turns);
+});
+
+await test('1003435 ACCEPTANCE: the reward reconciles with the session\'s cost_log rows', () => {
+  const inter = priceTranscript(fixture.mainPath);
+  const sub = priceSubagents(fixture.sessionDir);
+  const ledgerUsd = buildCostRows({ sessionId: PARALLEL_SID, inter, sub }).rowsTotal;
+  const rewardUsd = priceModelUsage(parallelDigest().metrics.model_usage).true_cost_usd;
+  assert.ok(Math.abs(rewardUsd - ledgerUsd) <= EPSILON,
+    `reward priced $${rewardUsd} but the ledger billed $${ledgerUsd}`);
+});
+
+await test('1003435 a parallel session is PAID for its subagents', async () => {
+  const client = fakeClient();
+  client.enqueue(NO_PRIOR);
+  client.enqueue([{ id: 99 }]);
+  const digest = parallelDigest();
+  const res = await awardSessionTokenReward(
+    client, 7, PARALLEL_SID, digest.metrics.model_usage, digest.totalTokens
+  );
+  assert.equal(res.awarded, true);
+  assert.equal(res.trueCostUsd, SESSION_USD);
+  assert.equal(res.drachmae, Math.round(SESSION_USD * 1.20)); // $6.10 × 1.20 = 7.32 → 7
+  // The bug this closes: interactive-only priced the same session at $2.50 → 3.
+  const before = computeSessionTokenReward(INTERACTIVE_USD).drachmae;
+  assert.ok(res.drachmae > before, `subagent-blind reward was ${before}, now ${res.drachmae}`);
+});
+
+await test('1003435 a re-ship of the same session is still a no-op (one award per session)', async () => {
+  const digest = parallelDigest();
+  const client = fakeClient();
+  // The watermark already holds everything this session is worth.
+  client.enqueue(ledger(Math.round(SESSION_USD * 1.20), 0));
+  const res = await awardSessionTokenReward(
+    client, 7, PARALLEL_SID, digest.metrics.model_usage, digest.totalTokens
+  );
+  assert.equal(res.awarded, false);
+  assert.equal(res.drachmae, 0);
+  assert.equal(client.queries.length, 1, 'SELECT only — a second upload must not pay again');
+});
+
+await test('1003435 a traversing session id folds NOTHING (the walk feeds a payout)', () => {
+  // The id is interpolated into a filesystem path whose contents get priced, so
+  // a `../` value could aim the walk at another directory and fold fabricated
+  // tokens into the reward. The on-ship caller screens the id before resolving
+  // the transcript; the SessionEnd hook takes it straight off stdin — so the
+  // guard lives in foldSubagentUsage, where every caller gets it.
+  const entries = parseJsonlText(fs.readFileSync(fixture.mainPath, 'utf8'));
+  const clean = buildSessionDigest(entries).metrics.model_usage;
+  for (const hostile of ['../' + PARALLEL_SID, `${PARALLEL_SID}/..`, 'a/../../etc', '']) {
+    const digest = foldSubagentUsage(buildSessionDigest(entries), fixture.mainPath, hostile);
+    assert.deepEqual(digest.metrics.model_usage, clean, `folded for id ${JSON.stringify(hostile)}`);
+    assert.equal(digest.metrics.subagent_files, undefined);
+  }
+  // …and the legitimate id still folds, so the guard is not just refusing everything.
+  const ok = foldSubagentUsage(buildSessionDigest(entries), fixture.mainPath, PARALLEL_SID);
+  assert.equal(ok.metrics.subagent_files, 2);
+});
+
+await test('1003435 usageOnly changes what is BUILT, never what is COUNTED', () => {
+  // The fold reuses buildSessionDigest so the token semantics — dedup by
+  // message.id, skip <synthetic>, fold unlabeled turns — have ONE home. usageOnly
+  // only drops the per-turn rows it would discard (and their snippet scrubbing,
+  // which the SessionEnd watchdog gives a hard time budget). If it ever changed a
+  // count, the reward and the ledger would quietly diverge again.
+  const entries = parseJsonlText(fs.readFileSync(fixture.mainPath, 'utf8'));
+  const full = buildSessionDigest(entries);
+  const lean = buildSessionDigest(entries, { usageOnly: true });
+  assert.deepEqual(lean.metrics.model_usage, full.metrics.model_usage);
+  assert.equal(lean.totalTokens, full.totalTokens);
+  assert.equal(lean.metrics.assistant_turns, full.metrics.assistant_turns);
+  assert.equal(lean.metrics.api_calls, full.metrics.api_calls);
+  assert.deepEqual(lean.detail, [], 'the detail rows are what usageOnly skips');
+  assert.ok(full.detail.length > 0);
+});
+
+await test('1003435 a session with no subagents is untouched (no regression)', () => {
+  const dir = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'otb-solo-'));
+  const mainPath = nodePath.join(dir, 'sess-solo.jsonl');
+  fs.writeFileSync(mainPath, asstLine('s1', 'claude-opus-4-8', { input_tokens: 110_000 }));
+  const entries = parseJsonlText(fs.readFileSync(mainPath, 'utf8'));
+  const before = buildSessionDigest(entries);
+  const after = foldSubagentUsage(buildSessionDigest(entries), mainPath, 'sess-solo');
+  assert.deepEqual(after.metrics.model_usage, before.metrics.model_usage);
+  assert.equal(after.metrics.subagent_files, undefined, 'no counters when there is nothing to count');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+fs.rmSync(fixture.dir, { recursive: true, force: true });
+
 // -------------------------------------------------------------------------
 // runner summary
 // -------------------------------------------------------------------------