@xhulz/nina 0.28.21 → 0.29.0

package/src/commands/stats.mjs

@@ -18,7 +18,7 @@ import { createReadStream, existsSync, readFileSync, realpathSync, statSync } fr
 import { createInterface } from 'node:readline';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { isLoopBack } from '../transcripts.mjs';
+import { ROLE_TOKENS, isLoopBack, runOf } from '../transcripts.mjs';
 import { frontmatter, pillFiles } from './pills.mjs';
 import { HARNESS, snapshotsDir } from '../paths.mjs';
 import { defaultVocabulary } from '../vocabulary.mjs';
@@ -26,20 +26,17 @@ import { layerRootFor } from './compose.mjs';
 import { PRICES_AS_OF, costOf } from '../prices.mjs';
 
 /**
- * The pipeline roles. A project that dispatches only generic agents
- * (`general-purpose`, `Explore`, `Plan`) is not running the harness, so it is left out
- * of the report by default — capture stays wide because losing a transcript is
- * irreversible, but measuring a pipeline against projects that have none is noise.
- */
-/**
- * The roles whose job is to approve or reject.
+ * The roles whose job is to approve or reject: every stage whose verdicts include no `-READY` token, the one
+ * a stage gives when it has produced something rather than ruled on it.
  *
  * Only these can be judged by loop-back rate. A planner, architect or implementer produces
  * work rather than ruling on it, so its rate is near zero by nature and says nothing — the
  * first version of this check used a sample size instead of a role list and therefore asked
- * the question of everyone, which is why it had to be silenced by a single loop-back.
+ * the question of everyone, which is why it had to be silenced by a single loop-back. Read from
+ * `ROLE_TOKENS` rather than listed here: the list here was written before the blockchain surface and never
+ * learned its auditor, so a blockchain project's gate was never judged as one.
  */
-const GATES = new Set(['reviewer', 'qa', 'dba', 'integration-tester', 'secops', 'devops']);
+const GATES = new Set(Object.entries(ROLE_TOKENS).filter(([, tokens]) => !tokens.some((t) => t.endsWith('-READY'))).map(([role]) => role));
 
 /** Below this rate a gate is worth a second look. The gates that do stop things sit near 20%. */
 const GATE_FLOOR = 0.05;
@@ -47,17 +44,13 @@ const GATE_FLOOR = 0.05;
 /** Fewer readable verdicts than this and the rate is noise, whatever it says. */
 const GATE_SAMPLE = 20;
 
-const PIPELINE_ROLES = new Set([
-  'planner',
-  'architect',
-  'implementer',
-  'dba',
-  'integration-tester',
-  'reviewer',
-  'qa',
-  'secops',
-  'devops',
-]);
+/**
+ * The pipeline roles: every stage a release composes, as `ROLE_TOKENS` names them. A project that
+ * dispatches only generic agents (`general-purpose`, `Explore`, `Plan`) is not running the harness, so it
+ * is left out of the report by default — capture stays wide because losing a transcript is irreversible,
+ * but measuring a pipeline against projects that have none is noise.
+ */
+const PIPELINE_ROLES = new Set(Object.keys(ROLE_TOKENS));
 
 /**
  * Loads snapshot records, optionally filtered.
@@ -157,6 +150,32 @@ export async function harvest(projects) {
 /** Formats a percentage, or a dash when there is nothing to divide by. */
 const pct = (n, d) => (d > 0 ? `${Math.round((n / d) * 100)}%` : '—');
 
+/**
+ * Records grouped by the run they are rounds of, each run's rounds in the order given.
+ *
+ * @param {object[]} records - Snapshot records, one per round.
+ * @returns {Map<string, object[]>}
+ */
+function byRun(records) {
+  const runs = new Map();
+  for (const r of records) runs.set(runOf(r), [...(runs.get(runOf(r)) ?? []), r]);
+  return runs;
+}
+
+/** How long a round may go without a report and still be running. The longest measured took 68 minutes. */
+const RUNNING_HOURS = 3;
+
+/**
+ * Whether a round that has no report is still running, rather than one that never reported or whose report
+ * the snapshot could not find. The two looked the same — neither forward, nor sent back, nor unreadable — so
+ * a change in Claude Code that hid every report would have left `stats` saying every verdict could be read.
+ *
+ * @param {object} r - A record.
+ * @param {number} now - Milliseconds since the epoch.
+ * @returns {boolean}
+ */
+const running = (r, now) => !r.verdict && now - Date.parse(r.ts) <= RUNNING_HOURS * 3_600_000;
+
 /**
  * What each stage cost, at API list prices, over the runs whose tokens were recorded. A gate that
  * rarely sends work back is a question of what it costs as much as of what it catches, and until the
@@ -167,16 +186,19 @@ const pct = (n, d) => (d > 0 ? `${Math.round((n / d) * 100)}%` : '—');
 function costReport(records) {
   const measured = records.filter((r) => r.tokens && typeof r.tokens === 'object');
   if (measured.length === 0) return;
+  // A run's cost is its rounds', so a reviewer resumed twice is one run at the price of three rounds.
   /** @type {Map<string, number[]>} */
   const byRole = new Map();
   let unpriced = 0;
-  for (const r of measured) {
-    const cost = costOf(r.tokens, r.usage_model);
-    if (cost === null) {
+  const runs = byRun(measured);
+  for (const rounds of runs.values()) {
+    const costs = rounds.map((r) => costOf(r.tokens, r.usage_model)).filter((c) => c !== null);
+    if (costs.length === 0) {
       unpriced += 1;
       continue;
     }
-    byRole.set(r.role, [...(byRole.get(r.role) ?? []), cost]);
+    const role = rounds[0].role;
+    byRole.set(role, [...(byRole.get(role) ?? []), costs.reduce((a, b) => a + b, 0)]);
   }
   const total = [...byRole.values()].flat().reduce((a, b) => a + b, 0);
   if (total === 0) return;
@@ -186,7 +208,7 @@ function costReport(records) {
   console.log(
     heading(
       'cost',
-      `at API list prices of ${PRICES_AS_OF}; ${measured.length} of ${records.length} runs have a token record` +
+      `at API list prices of ${PRICES_AS_OF}; ${runs.size} of ${byRun(records).size} runs have a token record` +
         (unpriced > 0 ? `, ${unpriced} on a model the price table does not know` : ''),
     ),
   );
@@ -269,13 +291,17 @@ function modelReport(records) {
   const lines = [];
   for (const [role, models] of changed) {
     const ordered = [...models].sort(([, a], [, b]) => String(a[0].ts).localeCompare(String(b[0].ts)));
-    for (const [i, [model, runs]] of ordered.entries()) {
-      const clear = runs.filter((r) => r.verdict && r.verdict !== 'UNCLEAR' && r.verdict !== 'NONE');
+    for (const [i, [model, rounds]] of ordered.entries()) {
+      const clear = rounds.filter((r) => r.verdict && r.verdict !== 'UNCLEAR' && r.verdict !== 'NONE');
       const loops = clear.filter((r) => isLoopBack(r.verdict)).length;
-      const costs = runs.map((r) => (r.tokens ? costOf(r.tokens, r.usage_model) : null)).filter((c) => c !== null);
-      const dates = runs.map((r) => String(r.ts).slice(0, 10)).sort();
+      const runs = byRun(rounds);
+      const costs = [...runs.values()]
+        .map((rs) => rs.map((r) => (r.tokens ? costOf(r.tokens, r.usage_model) : null)).filter((c) => c !== null))
+        .filter((cs) => cs.length > 0)
+        .map((cs) => cs.reduce((a, b) => a + b, 0));
+      const dates = rounds.map((r) => String(r.ts).slice(0, 10)).sort();
       lines.push(
-        `    ${i === 0 ? `${pink(role)}${' '.repeat(Math.max(20 - role.length, 1))}` : ''.padEnd(20)}${model.padEnd(26)}${String(runs.length).padStart(5)} run(s)  ${dim(`${dates[0]} → ${dates.at(-1)}`)}` +
+        `    ${i === 0 ? `${pink(role)}${' '.repeat(Math.max(20 - role.length, 1))}` : ''.padEnd(20)}${model.padEnd(26)}${String(runs.size).padStart(5)} run(s)  ${dim(`${dates[0]} → ${dates.at(-1)}`)}` +
           (clear.length ? `  loop-back ${pct(loops, clear.length)} of ${clear.length}` : '  no readable verdict') +
           (costs.length ? `  median ${money(median(costs))}` : ''),
       );
@@ -301,7 +327,7 @@ function modelReport(records) {
       if (other.length === 0) continue;
       const used = [...new Set(other.map((r) => r.usage_model))].join(', ');
       drift.push(
-        `    ${basename(dir)}: ${role} declares ${declared}, and ${other.length} of ${since.length} run(s) since that line last changed ran ${used} — an override no spec shows`,
+        `    ${basename(dir)}: ${role} declares ${declared}, and ${other.length} of ${since.length} round(s) since that line last changed ran ${used} — an override no spec shows`,
       );
     }
   }
@@ -422,7 +448,7 @@ function proportionReport(records, stepLimit = () => null) {
     const read = typeof largest.tokens?.read === 'number' ? `, ${Math.round(largest.tokens.read / 1e6)}M tokens read from cache` : '';
     console.log(
       note(
-        `${over.length} implementer run(s) wrote more files than one step may (${stepLimit(largest.project)}); the largest wrote ${largest.files_touched}${read}. The architect splits such a spec into steps.`,
+        `${over.length} implementer round(s) wrote more files than one step may (${stepLimit(largest.project)}); the largest wrote ${largest.files_touched}${read}. The architect splits such a spec into steps.`,
         'warn',
       ),
     );
@@ -537,18 +563,23 @@ export async function stats(argv, ctx) {
   const skipped = new Set(all.map((r) => r.project)).size - new Set(records.map((r) => r.project)).size;
 
   /**
-   * @type {Map<string, {n:number, done:number, clear:number, loop:number, unclear:number,
-   *   declared:number, durations:number[]}>}
+   * Per stage, counted in rounds: the verdicts are the rounds', and the loop gate counts rounds.
+   *
+   * @type {Map<string, {n:number, runs:Set<string>, done:number, lost:number, clear:number, loop:number,
+   *   unclear:number, declared:number, durations:number[]}>}
    */
   const byRole = new Map();
   // A dispatch a hook denied never ran, so it is neither a run nor a missing verdict.
   const held = records.filter((r) => r.status === 'denied').length;
+  const now = Date.now();
   for (const r of records.filter((r) => r.status !== 'denied')) {
     if (!byRole.has(r.role)) {
-      byRole.set(r.role, { n: 0, done: 0, clear: 0, loop: 0, unclear: 0, declared: 0, durations: [] });
+      byRole.set(r.role, { n: 0, runs: new Set(), done: 0, lost: 0, clear: 0, loop: 0, unclear: 0, declared: 0, durations: [] });
     }
     const s = byRole.get(r.role);
     s.n += 1;
+    s.runs.add(runOf(r));
+    if (!r.verdict && !running(r, now)) s.lost += 1;
     if (r.verdict) s.done += 1;
     if (r.verdict_source === 'declared' || r.verdict_source === 'handback') s.declared += 1;
     if (r.verdict === 'UNCLEAR' || r.verdict === 'NONE') s.unclear += 1;
@@ -561,17 +592,18 @@ export async function stats(argv, ctx) {
 
   const span = [records[0]?.ts, records.at(-1)?.ts].map((t) => String(t).slice(0, 10));
   const projectCount = new Set(records.map((r) => r.project)).size;
+  const run = byRun(records.filter((r) => r.status !== 'denied')).size;
   console.log(
-    `  ${projectCount === 1 ? `${bold(pink(projectName(records[0].project)))} · ` : ''}${bold(records.length)} dispatches · ${projectCount} project${projectCount === 1 ? '' : 's'} · ` +
+    `  ${projectCount === 1 ? `${bold(pink(projectName(records[0].project)))} · ` : ''}${bold(run)} runs in ${bold(records.length - held)} rounds · ${projectCount} project${projectCount === 1 ? '' : 's'} · ` +
       `${span[0]} → ${span[1]}` +
       (here ? dim('  (this project; --all for every project)') : '') +
       (skipped > 0 ? dim(`  (${skipped} non-harness project${skipped === 1 ? '' : 's'} hidden, --all to include)`) : '') +
       (held > 0 ? `  · ${held} dispatch(es) denied by a hook, not counted as runs` : ''),
   );
-  console.log(heading('stages', 'what each ran, and what came of it'));
+  console.log(heading('stages', 'what each ran, and what came of it; a round is one report, and a run resumed after it reported has one per report'));
   console.log(
     dim(
-      `    ${'stage'.padEnd(20)}${'runs'.padStart(6)}${'verdict'.padStart(9)}${'loop-back'.padStart(11)}` +
+      `    ${'stage'.padEnd(20)}${'runs'.padStart(6)}${'rounds'.padStart(9)}${'loop-back'.padStart(11)}` +
         `${'rate'.padStart(7)}${'declared'.padStart(10)}${'unreadable'.padStart(12)}` +
         `${'median'.padStart(9)}`,
     ),
@@ -592,24 +624,33 @@ export async function stats(argv, ctx) {
       Math.max(1, Math.round((16 * s.n) / busiest)),
     );
     const declared = pct(s.declared, s.done).padStart(10);
-    const unread = pct(s.unclear, s.done).padStart(12);
+    const unread = pct(s.unclear + s.lost, s.done + s.lost).padStart(12);
     console.log(
-      `    ${pink(role)}${' '.repeat(Math.max(20 - role.length, 1))}${String(s.n).padStart(6)}${String(s.clear).padStart(9)}` +
+      `    ${pink(role)}${' '.repeat(Math.max(20 - role.length, 1))}${String(s.runs.size).padStart(6)}${String(s.n).padStart(9)}` +
         `${zero(String(s.loop).padStart(11), s.loop)}${zero(pct(s.loop, s.clear).padStart(7), s.loop)}` +
-        `${s.declared < s.done ? amber(declared) : dim(declared)}${s.unclear > 0 ? amber(unread) : dim(unread)}` +
+        `${s.declared < s.done ? amber(declared) : dim(declared)}${s.unclear + s.lost > 0 ? amber(unread) : dim(unread)}` +
         `${medianMin(s.durations).padStart(9)}  ${runsBar}`,
     );
   }
   console.log(dim(`    ${' '.repeat(86)}█ forward  ▓ sent back  ░ no verdict read`));
 
   const unreadable = rows.reduce((a, [, s]) => a + s.unclear, 0);
+  const lost = rows.reduce((a, [, s]) => a + s.lost, 0);
   const done = rows.reduce((a, [, s]) => a + s.done, 0);
   console.log('');
-  console.log(
-    unreadable === 0
-      ? note("every finished run's verdict could be read.", 'ok')
-      : note(`${pct(unreadable, done)} of finished runs report no machine-readable verdict. Those stages need a verdict token on the report's first line.`, 'warn'),
-  );
+  if (unreadable === 0 && lost === 0) console.log(note("every finished round's verdict could be read.", 'ok'));
+  if (unreadable > 0) {
+    console.log(note(`${pct(unreadable, done + lost)} of finished rounds report no machine-readable verdict. Those stages need a verdict token on the report's first line.`, 'warn'));
+  }
+  if (lost > 0) {
+    console.log(
+      note(
+        `${lost} round(s) that started more than ${RUNNING_HOURS} hours ago have no report at all: a run that never finished, or a report ` +
+          "the snapshot could not find — which is how a change in Claude Code's transcripts first shows.",
+        'warn',
+      ),
+    );
+  }
 
   // Whether the stages that send work back say what they send back. Counted only over reports read
   // since the record learned the field, and only over declared loop-backs, which are all it asks of.
@@ -621,12 +662,14 @@ export async function stats(argv, ctx) {
     );
   }
 
-  const withSkills = records.filter((r) => r.agent_id && r.skills?.length > 0);
-  // Only a run whose own transcript could be located says anything about skill use.
-  const observable = records.filter((r) => r.agent_id).length;
+  // Only a run whose own transcript could be located says anything about skill use, and a skill a run
+  // invoked in one round is in front of it in every round after.
+  const skillsOf = [...byRun(records.filter((r) => r.agent_id)).values()].map((rounds) => [...new Set(rounds.flatMap((r) => r.skills ?? []))]);
+  const withSkills = skillsOf.filter((skills) => skills.length > 0);
+  const observable = skillsOf.length;
   if (observable > 0) {
     const tally = new Map();
-    for (const r of withSkills) for (const k of r.skills) tally.set(k, (tally.get(k) ?? 0) + 1);
+    for (const skills of withSkills) for (const k of skills) tally.set(k, (tally.get(k) ?? 0) + 1);
     const list = [...tally].sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ×${n}`);
     console.log(
       note(
@@ -652,7 +695,7 @@ export async function stats(argv, ctx) {
       `${role}: ${s.loop} loop-back(s) in ${s.clear} readable verdict(s) (${pct(s.loop, s.clear)}),` +
         ` against ${elsewhere} across the other gates — check whether it still gates anything.` +
         (s.n - s.clear > 0
-          ? ` ${s.n - s.clear} further run(s) produced no readable verdict at all, so the rate may understate it.`
+          ? ` ${s.n - s.clear} further round(s) produced no readable verdict at all, so the rate may understate it.`
           : '') +
         // A rate built from verdicts a parser guessed at is not the same claim as one built
         // from verdicts the stage declared, and the difference decides whether it can be acted on.
@@ -695,7 +738,7 @@ export async function stats(argv, ctx) {
     );
     if (newest) {
       const since = records.filter((r) => String(r.ts).slice(0, 10) > newest).length;
-      if (since > 0) console.log(note(`${since} dispatch(es) since the newest pill (${newest}).`));
+      if (since > 0) console.log(note(`${since} round(s) since the newest pill (${newest}).`));
     }
   }
   for (const name of pills.unresolved) {

package/src/commands/upgrade.mjs

@@ -436,6 +436,9 @@ export async function upgrade(argv, ctx) {
     {
       label: 'composing the harness files',
       run: () => {
+        // The files of the project's own that the move replaces are copied above; compose will not write
+        // over one, so each goes first, and a rollback puts it back.
+        for (const p of occupied) rmSync(join(target, p), { force: true });
         const r = nina(ctx, target, ['compose', '--project', target]);
         const wrote = /composed (\d+) file/.exec(r.out)?.[1];
         if (r.ok) for (const p of removable) rmSync(join(target, p), { force: true });

package/src/deep.mjs

@@ -17,11 +17,11 @@
  */
 
 import { spawnSync } from 'node:child_process';
-import { createReadStream, existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { createInterface } from 'node:readline';
 import { callsDir, childEnv, forgetProject, runFailure } from './commands/eval.mjs';
 import { isLoopBack, transcriptsOf } from './transcripts.mjs';
+import { readRun } from './agentrun.mjs';
 
 /** Reports per map call, and how much of each is sent: the cause is in the first screen of a report. */
 const BATCH = 15;
@@ -69,34 +69,6 @@ export const REDUCE_SCHEMA = {
   required: ['clusters'],
 };
 
-/**
- * The report a run handed back last — its final verdict and reasons — from its own transcript: the
- * `SubagentHandback` it called, or, for a run from before Claude Code had that tool, its last message,
- * which was the report then.
- *
- * @param {string} file - A subagent transcript.
- * @returns {Promise<string|null>}
- */
-async function handback(file) {
-  let report = null;
-  let last = null;
-  const rl = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
-  for await (const line of rl) {
-    const handed = line.includes('SubagentHandback');
-    if (!handed && !line.includes('"type":"assistant"')) continue;
-    try {
-      const row = JSON.parse(line);
-      for (const block of row?.message?.content ?? []) {
-        if (block?.type === 'tool_use' && block.name === 'SubagentHandback' && typeof block.input?.message === 'string') report = block.input.message;
-        if (row.type === 'assistant' && block?.type === 'text' && block.text.trim()) last = block.text;
-      }
-    } catch {
-      // A torn line loses one message, not the run.
-    }
-  }
-  return report ?? last;
-}
-
 /**
  * The loop-back reports still on disk for a project's records, newest first.
  *
@@ -121,7 +93,8 @@ export async function loopBackReports(records, projectDir, since) {
   let gone = 0;
   for (const r of wanted.sort((a, b) => String(b.ts).localeCompare(String(a.ts)))) {
     const file = files.get(r.agent_id);
-    const text = file ? await handback(file) : null;
+    // The round's own report: a run resumed after it reported holds one per round, and the last is not this one's.
+    const text = file ? (await readRun(file, r.round ?? 1))?.report : null;
     if (!text) {
       gone += 1;
       continue;

package/src/detectors.mjs

@@ -27,6 +27,33 @@ import { CHECK } from './wiring.mjs';
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
+/**
+ * The hook a detector runs under, in `NINA_HOOK`: `context` for the prompt hook, whose findings reach the
+ * model, `stop` for the Stop hook, whose one line reaches only the person, and nothing when run by hand.
+ *
+ * A finding that happens once — the gate failing, a lesson sent to the harness, an export that failed —
+ * used to be spent by whichever run saw it first, and that was usually the Stop hook: the person read one
+ * line saying the model would be told before their next message, and the prompt hook then found nothing
+ * new to tell it. Such a finding is now spent only by the run that hands it to the model
+ * (`handsToModel`), and every run before that reports it.
+ */
+const HOOK = 'NINA_HOOK';
+
+/**
+ * Whether this run is the one that hands its findings to the model, and so the one that may treat a
+ * finding that happens once as told.
+ *
+ * @returns {boolean}
+ */
+export const handsToModel = () => process.env[HOOK] === 'context';
+
+/**
+ * Whether this run is the Stop hook's, whose findings reach only the person.
+ *
+ * @returns {boolean}
+ */
+export const beforeModel = () => process.env[HOOK] === 'stop';
+
 /**
  * Runs one detector.
  *
@@ -37,9 +64,10 @@ import { join } from 'node:path';
  * @param {{name: string, declaredBy: string, script?: string, bin?: string, args: string[], ignore?: RegExp}} detector
  * @param {string} root - The project root.
  * @param {Set<string>} declared - The npm scripts the project declares.
+ * @param {string} hook - Which hook runs it (`HOOK`), or '' by hand.
  * @returns {{name: string, state: 'ok'|'drift'|'error'|'missing'|'n/a', detail: string}}
  */
-function runOne(detector, root, declared) {
+function runOne(detector, root, declared, hook) {
   // A detector with no `declaredBy` is one the harness ships to every project — the project has
   // nothing to opt into, and asking it to add an npm script first is how a detector ends up
   // installed and never run.
@@ -56,9 +84,10 @@ function runOne(detector, root, declared) {
   // installed the harness the documented way, vendored, would report the harness's own detector
   // as missing on every turn.
   const local = detector.bin ? join(root, 'node_modules', '.bin', detector.bin) : null;
+  const env = { ...process.env, [HOOK]: hook };
   const result = detector.bin
-    ? spawnSync(local && existsSync(local) ? local : detector.bin, detector.args, { cwd: root, encoding: 'utf8' })
-    : spawnSync(process.execPath, [path, ...detector.args], { cwd: root, encoding: 'utf8' });
+    ? spawnSync(local && existsSync(local) ? local : detector.bin, detector.args, { cwd: root, encoding: 'utf8', env })
+    : spawnSync(process.execPath, [path, ...detector.args], { cwd: root, encoding: 'utf8', env });
 
   if (result.error) {
     if (result.error.code === 'ENOENT') {
@@ -289,7 +318,7 @@ function remember(root, session, change) {
 export function runDetectors(detectors, options) {
   const { root, hook = false, context = false } = options;
   const declared = declaredIn(root);
-  const results = detectors.map((d) => runOne(d, root, declared));
+  const results = detectors.map((d) => runOne(d, root, declared, context ? 'context' : hook ? 'stop' : ''));
   const applicable = results.filter((r) => r.state !== 'n/a');
   const drift = results.filter((r) => r.state === 'drift');
   const errored = results.filter((r) => r.state === 'error');

package/src/gate.mjs

@@ -73,7 +73,7 @@ const DELIVERED = /<(task-notification|agent-message|cross-session-message|teamm
 const DELIVERY_HEAD = 300;
 
 /** The most of a ledger ever read. The owner's last reply bounds what counts, and a session this long is rare. */
-const LEDGER_TAIL = 4 * 1024 * 1024;
+export const LEDGER_TAIL = 4 * 1024 * 1024;
 
 /** The most of a subagent's own transcript read looking for its handback. */
 const AGENT_TAIL = 512 * 1024;

package/src/langfuse.mjs

@@ -131,6 +131,8 @@ export function spanOf(record, project, context = null) {
   if (typeof record.files_touched === 'number') attributes.push(attribute('langfuse.observation.metadata.files_touched', record.files_touched));
   if (record.branch) attributes.push(attribute('langfuse.observation.metadata.branch', record.branch));
   if (record.effort) attributes.push(attribute('langfuse.observation.metadata.effort', record.effort));
+  // A round after the first is the same agent resumed after it reported; the trace says which.
+  if (typeof record.round === 'number') attributes.push(attribute('langfuse.observation.metadata.round', record.round));
   if (tokens) attributes.push(...usageAttributes(tokens, record.usage_model, record.usage_model));
   if (context) {
     attributes.push(attribute('langfuse.observation.input', context.prompt ?? ''));