@xhulz/nina 0.33.0 → 0.35.0

package/src/commands/stats.mjs

@@ -14,13 +14,13 @@
 import { amber, bar, bold, dim, heading, note, pink, stacked } from '../look.mjs';
 import { readFile, readdir } from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
-import { createReadStream, existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { closeSync, createReadStream, existsSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { ROLE_TOKENS, isLoopBack, runOf } from '../transcripts.mjs';
+import { ROLE_TOKENS, isLoopBack, runOf, transcriptsOf } from '../transcripts.mjs';
 import { frontmatter, pillFiles } from './pills.mjs';
-import { HARNESS, snapshotsDir } from '../paths.mjs';
+import { HARNESS, slugFor, snapshotsDir } from '../paths.mjs';
 import { defaultVocabulary } from '../vocabulary.mjs';
 import { layerRootFor } from './compose.mjs';
 import { PRICES_AS_OF, costOf } from '../prices.mjs';
@@ -80,17 +80,64 @@ async function load(dir, opts) {
 }
 
 
+/** Directories already found for an encoded name: `stats` asks for the same project many times over. */
+const decoded = new Map();
+
+/**
+ * The directory a project's sessions ran in, as its own transcripts record it: every line carries the
+ * session's `cwd`. Taken only when it encodes back to the same name and is still there.
+ *
+ * @param {string} encoded - A snapshot's project name, which is also its transcript directory's.
+ * @returns {string|null}
+ */
+function recordedDir(encoded) {
+  const dir = transcriptsOf(encoded);
+  let files = [];
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+  } catch {
+    return null;
+  }
+  for (const file of files.slice(0, 5)) {
+    let head = '';
+    try {
+      const fd = openSync(join(dir, file), 'r');
+      try {
+        const buffer = Buffer.alloc(64 * 1024);
+        head = buffer.toString('utf8', 0, readSync(fd, buffer, 0, buffer.length, 0));
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+      continue;
+    }
+    for (const line of head.split('\n')) {
+      let cwd;
+      try {
+        cwd = JSON.parse(line)?.cwd;
+      } catch {
+        continue;
+      }
+      if (typeof cwd === 'string' && slugFor(cwd) === encoded && existsSync(cwd)) return cwd;
+    }
+  }
+  return null;
+}
+
 /**
  * Turns a snapshot's encoded project name back into a directory.
  *
- * The encoding replaces every separator with a dash, so `Code-IA-harness` could be
- * `Code/IA/harness` or `Code/IA-harness` and the string alone cannot say which. The
- * filesystem can, so the split is resolved against it rather than guessed.
+ * The encoding makes every character that is not a letter or a digit a dash, so the name alone cannot say
+ * what it was. The project's transcripts can: each line records the directory its session ran in. Failing
+ * that, the split is resolved against the file system — which can only rebuild `/` from a dash, so a
+ * project whose path held a `.`, a space or an `_` was never found, and its pills, models and requests went
+ * missing from every report without a word.
  *
  * @param {string} encoded - The `project` field of a snapshot record.
  * @returns {string | null} The directory, or `null` when no split of the name exists.
  */
 export function decodeProjectDir(encoded) {
+  if (decoded.has(encoded)) return decoded.get(encoded);
   const parts = encoded.replace(/^-/, '').split('-');
   const walk = (base, i) => {
     if (i === parts.length) return base;
@@ -102,7 +149,10 @@ export function decodeProjectDir(encoded) {
     }
     return null;
   };
-  return walk('/', 0);
+  const found = recordedDir(encoded) ?? walk('/', 0);
+  // Only what was found: a directory made after a miss is found the next time it is asked for.
+  if (found) decoded.set(encoded, found);
+  return found;
 }
 
 /**
@@ -224,8 +274,8 @@ function costReport(records) {
 }
 
 /**
- * How each stage's rounds spent their context: turns, tool calls sent per turn, and the context a turn
- * re-read when the round began and at its largest. Every turn is billed the whole context again, so the
+ * How each stage's rounds spent their context: turns, tool calls sent per turn, the context a turn
+ * re-read when the round began and at its largest, and how long the prompt that opened the round was. Every turn is billed the whole context again, so the
  * cost of a round is its turns times its context, and a round that starts where a long one ended pays for
  * all of it on every turn. The first rounds of a run are set beside the later ones, which are resumes.
  *
@@ -236,8 +286,9 @@ function contextReport(records) {
   if (shaped.length === 0) return;
   const median = (xs) => [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)];
   const k = (n) => (typeof n === 'number' ? `${Math.round(n / 1000)}k` : '—');
-  console.log(heading('context', 'every turn re-reads the whole context: a round costs its turns times its size, and a resumed one starts where it ended'));
-  console.log(dim(`    ${'stage'.padEnd(20)}${'rounds'.padEnd(8)}${'n'.padStart(4)}${'turns'.padStart(7)}${'calls/turn'.padStart(12)}${'starts at'.padStart(11)}${'peak'.padStart(8)}`));
+  const chars = (xs) => (xs.length ? median(xs).toLocaleString('en-US') : '—');
+  console.log(heading('context', 'every turn re-reads the whole context: a round costs its turns times its size, and a resumed one starts where it ended; the prompt it was handed is in characters'));
+  console.log(dim(`    ${'stage'.padEnd(20)}${'rounds'.padEnd(8)}${'n'.padStart(4)}${'turns'.padStart(7)}${'calls/turn'.padStart(12)}${'starts at'.padStart(11)}${'peak'.padStart(8)}${'prompt'.padStart(9)}`));
   const byRole = new Map();
   for (const r of shaped) byRole.set(r.role, [...(byRole.get(r.role) ?? []), r]);
   for (const [role, rounds] of [...byRole].sort((a, b) => b[1].reduce((x, r) => x + r.turns, 0) - a[1].reduce((x, r) => x + r.turns, 0))) {
@@ -251,7 +302,8 @@ function contextReport(records) {
       const name = i === 0 || !rounds.some((r) => (r.round ?? 1) === 1) ? pink(role) + ' '.repeat(Math.max(20 - role.length, 1)) : ' '.repeat(20);
       console.log(
         `    ${name}${dim(label.padEnd(8))}${String(group.length).padStart(4)}${String(median(group.map((r) => r.turns))).padStart(7)}` +
-          `${(calls / turns).toFixed(2).padStart(12)}${k(median(group.map((r) => r.context_start ?? 0))).padStart(11)}${k(median(group.map((r) => r.context_peak ?? 0))).padStart(8)}`,
+          `${(calls / turns).toFixed(2).padStart(12)}${k(median(group.map((r) => r.context_start ?? 0))).padStart(11)}${k(median(group.map((r) => r.context_peak ?? 0))).padStart(8)}` +
+          `${chars(group.map((r) => r.prompt_chars).filter((n) => typeof n === 'number')).padStart(9)}`,
       );
     });
   }

package/src/commands/upgrade.mjs

@@ -6,16 +6,15 @@
  * already wrote that the new harness has nowhere to put. A slot that was renamed or dropped
  * takes the project's own text out of the composition with it, silently, because a fragment
  * nothing references composes to nothing and no check notices. So this reports first and
- * writes only when told to, and what it writes is one field: the version. Reconciling the
- * fragments is work, and work does not get done by a flag.
+ * writes only when told to. Reconciling the fragments is work, and work does not get done by a flag.
  */
 
-import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
-import { HARNESS, legacyHint } from '../paths.mjs';
-import { existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { HARNESS, describeMove, interruptedMove, legacyHint, moveJournal, movedFrom } from '../paths.mjs';
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { composeProject, composedPaths, defaultedSlots, layerRootFor, walk } from './compose.mjs';
+import { REMOVED, composeProject, composedPaths, defaultedSlots, layerRootFor, walk } from './compose.mjs';
 import { NEEDS, detected } from '../surfaces.mjs';
 import { filledSlots, projectSlots, referencedVocabulary } from './check.mjs';
 import { EXPECT_ENV } from '../expected.mjs';
@@ -25,6 +24,9 @@ import { missingFragment, missingWiring, shippedScripts } from '../wiring.mjs';
 import { runSteps } from '../steps.mjs';
 import { defaultVocabulary } from '../vocabulary.mjs';
 
+/** What stops a move from outside it: Ctrl-C, a `kill`, the terminal closing. */
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+
 /** Banner lines, which are for a person watching and only noise inside a captured log. */
 const BANNER = /^[\s█╗╔╝║═╚▄▀]*$|harness orchestration ·/;
 
@@ -75,7 +77,7 @@ function nina(ctx, target, args) {
     cwd: target,
     encoding: 'utf8',
   });
-  const out = [result.stdout ?? '', result.stderr ?? '']
+  const out = [result.stdout ?? '', result.stderr ?? '', result.signal ? `stopped by ${result.signal}` : '']
     .join('\n')
     .split('\n')
     .filter((line) => line.trim() && !BANNER.test(line))
@@ -121,7 +123,7 @@ function shell(target, script) {
     encoding: 'utf8',
     env: { ...process.env, PATH: `${join(target, 'node_modules', '.bin')}:${process.env.PATH ?? ''}` },
   });
-  const out = [result.stdout ?? '', result.stderr ?? ''].join('\n').split('\n').filter((l) => l.trim()).join('\n');
+  const out = [result.stdout ?? '', result.stderr ?? '', result.signal ? `stopped by ${result.signal}` : ''].join('\n').split('\n').filter((l) => l.trim()).join('\n');
   return { ok: result.status === 0, out, summary: summarise(out) };
 }
 
@@ -157,6 +159,74 @@ function summarise(out) {
   return [...lines].reverse().find((l) => /^\w[\w ]*:/.test(l))?.trim();
 }
 
+/**
+ * Puts a project back on the version a move started from: the pin, then the files the move composed for the
+ * first time removed, a recompose, and every file it could touch written back as it was — the recompose alone
+ * would write the old composition over the owner's own edits and call it restored.
+ *
+ * @param {{root: string}} ctx - CLI context.
+ * @param {string} target - The project.
+ * @param {string} profilePath - Its profile.
+ * @param {object} profile - The profile as read, whose pin is set back.
+ * @param {string} version - The version the move started from.
+ * @param {string[]} created - Paths the move composed where nothing was.
+ * @param {Map<string, Buffer>} saved - Every file the move could touch, as it was.
+ * @returns {boolean} Whether the recompose passed.
+ */
+function restore(ctx, target, profilePath, profile, version, created, saved) {
+  profile.core = version;
+  writeFileSync(profilePath, `${JSON.stringify(profile, null, 2)}\n`);
+  for (const p of created) rmSync(join(target, p), { force: true });
+  const recomposed = nina(ctx, target, ['compose', '--project', target]);
+  for (const [p, bytes] of saved) {
+    mkdirSync(dirname(join(target, p)), { recursive: true });
+    writeFileSync(join(target, p), bytes);
+  }
+  return recomposed.ok;
+}
+
+/**
+ * `nina upgrade --abort`: undoes a move that was stopped before it finished, from what it wrote down first.
+ *
+ * @param {{root: string}} ctx - CLI context.
+ * @param {string} target - The project.
+ * @param {string} profilePath - Its profile.
+ * @param {object} profile - The profile as read.
+ * @param {ReturnType<typeof interruptedMove>} stopped - The move it was left in.
+ * @returns {number} Process exit code.
+ */
+function abort(ctx, target, profilePath, profile, stopped) {
+  if (!stopped) {
+    console.log('  no upgrade was stopped half-way here — there is nothing to undo.\n');
+    return 0;
+  }
+  if (stopped.unreadable) {
+    console.error(
+      `  ${describeMove(stopped)} Nothing can be undone from it: set "core" in ${HARNESS}/profile.json back by hand, run \`nina compose\`, ` +
+        `and delete ${HARNESS}/upgrade.json.\n`,
+    );
+    return 1;
+  }
+  const saved = new Map();
+  for (const p of stopped.saved ?? []) {
+    const copy = join(movedFrom(target), p);
+    if (existsSync(copy)) saved.set(p, readFileSync(copy));
+  }
+  const lost = (stopped.saved ?? []).filter((p) => !saved.has(p));
+  if (lost.length > 0) {
+    console.error(`  ${lost.length} of the files the move kept are missing from ${HARNESS}/upgrade-saved/, so it cannot be undone exactly: ${lost.slice(0, 5).join(', ')}${lost.length > 5 ? ', …' : ''}\n`);
+    return 1;
+  }
+  const recomposed = restore(ctx, target, profilePath, profile, stopped.from, stopped.created ?? [], saved);
+  rmSync(moveJournal(target), { force: true });
+  rmSync(movedFrom(target), { recursive: true, force: true });
+  console.log(
+    `  undid the move to ${stopped.to}: pinned ${stopped.from} again and put ${saved.size} file(s) back as they were.` +
+      `${recomposed ? '' : ' Recomposing failed along the way — run `nina compose` yourself.'} Run the move again when ready.\n`,
+  );
+  return recomposed ? 0 : 1;
+}
+
 /**
  * `nina upgrade`.
  *
@@ -176,6 +246,15 @@ export async function upgrade(argv, ctx) {
   }
   const profile = JSON.parse(await readFile(profilePath, 'utf8'));
 
+  // A move stopped half-way comes before anything else asked of this command: its pin may already name the
+  // version it was moving to, and "already pins" left the tree half-moved for good.
+  const stopped = interruptedMove(target);
+  if (argv.includes('--abort')) return abort(ctx, target, profilePath, profile, stopped);
+  if (stopped) {
+    console.error(`  ${describeMove(stopped)} \`nina upgrade --abort --project ${target}\` undoes it; then run the move again.\n`);
+    return 1;
+  }
+
   const to = arg('--to');
   if (!to) {
     console.error('  usage: nina upgrade --to <version> [--project <dir>] [--apply]\n');
@@ -354,10 +433,6 @@ export async function upgrade(argv, ctx) {
   }
 
   const previous = profile.core;
-  const pin = async (version) => {
-    profile.core = version;
-    await writeFile(profilePath, `${JSON.stringify(profile, null, 2)}\n`);
-  };
 
   // What was already failing is not this upgrade's doing, and rolling back for it would blame
   // the move for a problem the project brought with it. Measured before anything is written,
@@ -437,8 +512,12 @@ export async function upgrade(argv, ctx) {
   const keptEdited = dropped.filter((p) => edited.has(p));
   // Every file the move can touch, as it is now, so a rollback puts the tree back exactly — the
   // recompose alone would write the old composition over the owner's own edits and call it restored.
+  // That is every path either version composes for any surface, not only the declared ones: compose moves
+  // a file gated on an undeclared surface to .nina/removed/, and one left out of here stayed there after a
+  // rollback that said the tree was as it was.
+  const reachable = [...(await composedPaths(from.dir, offeredBefore)), ...(await composedPaths(onto.dir, available))];
   const saved = new Map();
-  for (const p of new Set([...pathsBefore, ...pathsAfter])) {
+  for (const p of new Set([...pathsBefore, ...pathsAfter, ...reachable])) {
     const entry = entryAt(p);
     if (entry?.isFile()) saved.set(p, readFileSync(join(target, p)));
   }
@@ -449,7 +528,31 @@ export async function upgrade(argv, ctx) {
     writeFileSync(copy, saved.get(p) ?? readFileSync(join(target, p)));
   }
 
-  await pin(to);
+  // All of it written down before the pin moves, copies first and the journal last, so a journal always has
+  // its copies. A move stopped from here on — Ctrl-C, a closed terminal, a crash — left the pin moved, the tree
+  // half-composed, and the owner's own edits, held only in this process's memory, gone; now the next run says
+  // so, and `--abort` undoes it.
+  rmSync(movedFrom(target), { recursive: true, force: true });
+  for (const [p, bytes] of saved) {
+    mkdirSync(dirname(join(movedFrom(target), p)), { recursive: true });
+    writeFileSync(join(movedFrom(target), p), bytes);
+  }
+  const journal = { from: previous, to, started: new Date().toISOString(), created, saved: [...saved.keys()] };
+  writeFileSync(`${moveJournal(target)}.tmp`, `${JSON.stringify(journal, null, 2)}\n`);
+  renameSync(`${moveJournal(target)}.tmp`, moveJournal(target));
+  // Ctrl-C reaches the step running in a child too, which dies of it, and its step fails: with this process
+  // still alive, that is an ordinary failed step, and the move rolls back. Without a listener this process died
+  // first, half-way through, with nothing left to roll anything back.
+  const hold = () => {};
+  for (const s of SIGNALS) process.on(s, hold);
+  const settle = () => {
+    for (const s of SIGNALS) process.off(s, hold);
+    rmSync(moveJournal(target), { force: true });
+    rmSync(movedFrom(target), { recursive: true, force: true });
+  };
+
+  profile.core = to;
+  writeFileSync(profilePath, `${JSON.stringify(profile, null, 2)}\n`);
   console.log(`  pinned ${to}\n`);
 
   const steps = [
@@ -473,12 +576,20 @@ export async function upgrade(argv, ctx) {
   const { failed } = runSteps(steps);
 
   if (!failed) {
+    settle();
     delete process.env.NINA_UPGRADE;
     console.log(`\n  upgrade: ${previous} → ${to} applied and verified.`);
     if (removable.length > 0) console.log(`\n  removed ${removable.length} file(s) ${to} no longer composes: ${removable.join(', ')}`);
-    if (keptEdited.length > 0) {
-      console.log(`\n  kept ${keptEdited.length} file(s) ${to} no longer composes, because they carry edits of yours — delete them once nothing in them is needed:`);
-      for (const p of keptEdited) console.log(`      ${p}`);
+    // A file gated on a surface the project does not declare is moved aside by compose itself, edited or not.
+    const stillKept = keptEdited.filter((p) => entryAt(p));
+    const setAside = keptEdited.filter((p) => !entryAt(p));
+    if (stillKept.length > 0) {
+      console.log(`\n  kept ${stillKept.length} file(s) ${to} no longer composes, because they carry edits of yours — delete them once nothing in them is needed:`);
+      for (const p of stillKept) console.log(`      ${p}`);
+    }
+    if (setAside.length > 0) {
+      console.log(`\n  moved ${setAside.length} file(s) with edits of yours to ${REMOVED}/, since ${to} composes them only for a surface this project does not declare:`);
+      for (const p of setAside) console.log(`      ${p}`);
     }
     if (occupied.length > 0) {
       console.log(`\n  replaced ${occupied.length} file(s) of yours with what ${to} composes there — the originals are in ${HARNESS}/replaced/:`);
@@ -530,15 +641,10 @@ export async function upgrade(argv, ctx) {
   }
 
   console.log(`\n  ✗ ${failed.label} failed — rolling back to ${previous}.\n`);
-  await pin(previous);
-  for (const p of created) rmSync(join(target, p), { force: true });
-  const recomposed = nina(ctx, target, ['compose', '--project', target]);
-  for (const [p, bytes] of saved) {
-    mkdirSync(dirname(join(target, p)), { recursive: true });
-    writeFileSync(join(target, p), bytes);
-  }
+  const recomposed = restore(ctx, target, profilePath, profile, previous, created, saved);
+  settle();
   console.log(
-    recomposed.ok
+    recomposed
       ? `  rolled back: pinned ${previous} and recomposed. The tree is as it was.\n`
       : `  rolled back the pin to ${previous}, but recomposing failed — run \`nina compose\` yourself.\n`,
   );

package/src/guard.mjs

@@ -20,21 +20,18 @@
 import { closeSync, existsSync, openSync, readFileSync, readSync, realpathSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { composedPaths } from './commands/compose.mjs';
+import { NOTICE_HEAD, composedPaths, noticeOf } from './commands/compose.mjs';
 import { HARNESS } from './paths.mjs';
 
+// Read here and by the suites from here; the test itself lives beside the compiler that writes the notice.
+export { NOTICE_HEAD, noticeOf };
+
 /** The package this runs from: its releases say whether a pinned version ships the guard. */
 const PACKAGE = dirname(dirname(fileURLToPath(import.meta.url)));
 
 /** The tools that change a file, and where each names it. */
 const EDITS = { Edit: 'file_path', Write: 'file_path', MultiEdit: 'file_path', NotebookEdit: 'notebook_path' };
 
-/**
- * How far into a file the notice is looked for: below a frontmatter block, or a shebang. The compose
- * suite holds every composed file's notice inside it.
- */
-export const NOTICE_HEAD = 60;
-
 /** How much of a file is read to find it: the head, not the whole of a large file on every edit. */
 const HEAD_BYTES = 16 * 1024;
 
@@ -69,35 +66,6 @@ function head(path) {
   }
 }
 
-/**
- * A composed file's notice, as one sentence without its comment syntax, or null when it has none.
- *
- * @param {string} text - The file.
- * @returns {string|null}
- */
-export function noticeOf(text) {
-  const lines = String(text).split('\n').slice(0, NOTICE_HEAD);
-  const at = lines.findIndex((l) => /^(<!--|\/\/) nina:generated/.test(l));
-  if (at < 0) return null;
-  const block = [];
-  if (lines[at].startsWith('//')) {
-    for (const line of lines.slice(at)) {
-      if (!line.startsWith('//')) break;
-      block.push(line.replace(/^\/\/ ?/, ''));
-    }
-  } else {
-    // The notice's own delimiters, taken off by position: this reads text the compiler wrote, it filters
-    // nothing, and a pattern for it read to a scanner as an HTML sanitizer that misses `--!>`.
-    for (const line of lines.slice(at)) {
-      const open = line.startsWith('<!-- ') ? line.slice('<!-- '.length) : line;
-      const end = open.lastIndexOf('-->');
-      block.push(end >= 0 ? open.slice(0, end) : open);
-      if (end >= 0) break;
-    }
-  }
-  return block.map((l) => l.trim()).join(' ');
-}
-
 /**
  * Handles one hook event: the JSON to print, or null to let the call through. Never throws.
  *
@@ -121,7 +89,9 @@ export async function handleEdit(input, { root, pkg = PACKAGE }) {
     if (!pinned) return null;
     const target = isAbsolute(path) ? path : resolve(input.cwd ?? root, path);
     if (!existsSync(target)) return null;
-    const rel = relative(realpathSync(root), realpathSync(target)).split(sep).join('/');
+    // The native call returns the name as it is on disk: where case is ignored, `claude.md` is CLAUDE.md, and
+    // read as spelled it reached no composed path and let the edit through.
+    const rel = relative(realpathSync.native(root), realpathSync.native(target)).split(sep).join('/');
     // Outside the project, or in its own layer — where a change to a composed file belongs.
     if (rel.startsWith('..') || isAbsolute(rel) || rel.split('/')[0] === HARNESS) return null;
     const notice = noticeOf(head(target));

package/src/langfuse.mjs

@@ -100,31 +100,47 @@ function usageAttributes(tokens, model, priced) {
   return out;
 }
 
+/**
+ * How much of a stage's context a project sends, from its switch in the Langfuse configuration: all of it
+ * (`--content`), only what passed between the agents (`--prompts`), or none.
+ *
+ * @param {{content?: boolean|string}|undefined} setting - The project's entry, if it is on.
+ * @returns {'full'|'prompts'|null}
+ */
+export function contextMode(setting) {
+  return setting?.content === 'prompts' ? 'prompts' : setting?.content ? 'full' : null;
+}
+
+/** A round's shape, as metadata on its root: how many turns and calls it took, and how large its context and prompt were. */
+const SHAPE = ['turns', 'tool_calls', 'context_start', 'context_peak', 'prompt_chars'];
+
 /**
  * The OTLP span at the root of a dispatch's trace. Without its context, a run that spent tokens is a
  * generation carrying the run's whole usage and estimated cost, and one that did not is a span. With it,
  * the root is the agent — its prompt in, its report out — and the usage is on the messages beneath it,
- * so no sum counts a token twice. Its verdict is the score beside it rather than an attribute on it: a
- * run whose verdict is read only later can still be given one, since that is a first score and not a
- * second span.
+ * so no sum counts a token twice. With the prompt and report alone, nothing is beneath it, so the root is
+ * a generation again, carrying the usage beside them. Its verdict is the score beside it rather than an
+ * attribute on it: a run whose verdict is read only later can still be given one, since that is a first
+ * score and not a second span.
  *
  * @param {object} record - A snapshot record.
  * @param {string} project - The name the project goes by in Langfuse.
  * @param {{prompt: string, report: string}} [context] - What the stage was given and handed back.
+ * @param {{usage?: boolean}} [options] - `usage`: the root carries the usage even with its context.
  * @returns {object|null} Null for a record with no time to place it at.
  */
-export function spanOf(record, project, context = null) {
+export function spanOf(record, project, context = null, { usage = false } = {}) {
   const start = nanos(record.ts);
   if (!start) return null;
   const end = nanos(record.result_ts) ?? start;
-  const tokens = !context && record.tokens && typeof record.tokens === 'object' ? record.tokens : null;
+  const tokens = (!context || usage) && record.tokens && typeof record.tokens === 'object' ? record.tokens : null;
   const attributes = [
     attribute('langfuse.session.id', record.session ?? 'no-session'),
     attribute('langfuse.trace.name', record.role),
     attribute('langfuse.trace.tags', ['nina', project]),
     attribute('langfuse.trace.metadata.project', project),
     attribute('langfuse.trace.metadata.role', record.role),
-    attribute('langfuse.observation.type', context ? 'agent' : tokens ? 'generation' : 'span'),
+    attribute('langfuse.observation.type', tokens ? 'generation' : context ? 'agent' : 'span'),
     attribute('langfuse.observation.metadata.role', record.role),
   ];
   if (typeof record.issues === 'number') attributes.push(attribute('langfuse.observation.metadata.issues', record.issues));
@@ -133,6 +149,7 @@ export function spanOf(record, project, context = null) {
   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));
+  for (const key of SHAPE) if (typeof record[key] === 'number') attributes.push(attribute(`langfuse.observation.metadata.${key}`, record[key]));
   if (tokens) attributes.push(...usageAttributes(tokens, record.usage_model, record.usage_model));
   if (context) {
     attributes.push(attribute('langfuse.observation.input', context.prompt ?? ''));
@@ -144,23 +161,26 @@ export function spanOf(record, project, context = null) {
 /**
  * Everything a dispatch sends: the root, and — when its context goes too — a generation per message it
  * wrote, with that message's own tokens and cost, and an observation per tool it called, with what went
- * in and what came back. Every text is masked (`redact`), cut to a length, and has the owner's home
- * directory written as `~`.
+ * in and what came back. With `prompts`, only what passed between the agents goes: the root, with the
+ * prompt the stage was given and the report it handed back, and none of what it read, wrote or called in
+ * between. Every text is masked (`redact`), cut to a length, and has the owner's home directory written
+ * as `~`.
  *
  * @param {object} record - A snapshot record.
  * @param {string} project - The name the project goes by in Langfuse.
  * @param {object|null} run - From `readRun`, or null to send the record alone.
  * @param {{text?: number, tool?: number}} [limits] - How much of each text goes.
+ * @param {{prompts?: boolean}} [options] - `prompts`: the prompt and the report, and nothing beneath them.
  * @returns {object[]} Spans; empty for a record with no time to place it at.
  */
-export function spansOf(record, project, run, limits = {}) {
+export function spansOf(record, project, run, limits = {}, { prompts = false } = {}) {
   const textChars = limits.text ?? TEXT_CHARS;
   const toolChars = limits.tool ?? TOOL_CHARS;
   const home = homedir();
   const clean = (text, chars) => clip(redact(String(text ?? '')).replaceAll(home, '~'), chars);
-  const root = spanOf(record, project, run ? { prompt: clean(run.prompt, textChars), report: clean(run.report, textChars) } : null);
+  const root = spanOf(record, project, run ? { prompt: clean(run.prompt, textChars), report: clean(run.report, textChars) } : null, { usage: prompts });
   if (!root) return [];
-  if (!run) return [root];
+  if (!run || prompts) return [root];
   const child = (id, name, start, end, attributes) => ({
     traceId: root.traceId,
     spanId: hexId(`${record.dispatch_id}|${id}`, 16),

package/src/paths.mjs

@@ -8,7 +8,7 @@
  * project, and losing it is irreversible — so it lives in the user's own directory.
  */
 
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 
@@ -100,3 +100,52 @@ export function legacyHint(target) {
     ? ` — this project still has .harness/, which is what ${HARNESS}/ used to be called. Rename it; do not start over.`
     : '';
 }
+
+/**
+ * Where `nina upgrade --apply` writes down a move while it is in flight: the versions it moves between, the
+ * files it composes for the first time, and — under {@link movedFrom} — every file it can touch, as it was.
+ * It is written before the pin moves and removed once the move is verified or rolled back, so one that is
+ * still there is a move that was stopped half-way.
+ *
+ * @param {string} target - The project.
+ * @returns {string}
+ */
+export const moveJournal = (target) => join(target, HARNESS, 'upgrade.json');
+
+/**
+ * Where an in-flight move keeps the files it can touch, as they were before it — at their own paths below.
+ *
+ * @param {string} target - The project.
+ * @returns {string}
+ */
+export const movedFrom = (target) => join(target, HARNESS, 'upgrade-saved');
+
+/**
+ * The move a project was left in when `upgrade --apply` was stopped before it finished, or null when none is.
+ *
+ * A pin that moved with the composed files half-written looks like hand edits to every check, and the
+ * owner's own edits it was about to put back lived only in the stopped process's memory. This is what says
+ * so instead, and what `nina upgrade --abort` undoes it from.
+ *
+ * @param {string} target - The project.
+ * @returns {{from: string, to: string, started: string, created: string[], saved: string[]}|{unreadable: string}|null}
+ */
+export function interruptedMove(target) {
+  try {
+    return JSON.parse(readFileSync(moveJournal(target), 'utf8'));
+  } catch (error) {
+    return error.code === 'ENOENT' ? null : { unreadable: error.message };
+  }
+}
+
+/**
+ * A stopped move, said once for every command that finds one.
+ *
+ * @param {NonNullable<ReturnType<typeof interruptedMove>>} stopped - The move.
+ * @returns {string}
+ */
+export function describeMove(stopped) {
+  return stopped.unreadable
+    ? `An upgrade was stopped before it finished, and its journal ${HARNESS}/upgrade.json cannot be read (${stopped.unreadable}).`
+    : `An upgrade from ${stopped.from} to ${stopped.to}, started ${stopped.started}, was stopped before it finished — the pin and the composed files may be half-moved.`;
+}

package/src/prices.mjs

@@ -15,7 +15,7 @@
 /** The date the table was read, printed beside every estimate made from it. */
 export const PRICES_AS_OF = '2026-06-24';
 
-/** model id prefix → $/MTok. Longest prefix wins, so `claude-opus-5-5` is not read as `claude-opus-5`. */
+/** model id → $/MTok. */
 const PRICES = {
   'claude-fable-5-1': { input: 10, output: 50, read: 0.25 },
   'claude-mythos-5-1': { input: 10, output: 50 },
@@ -39,12 +39,12 @@ const PRICES = {
  * @returns {{input: number, output: number, read: number, write5m: number, write1h: number}|null}
  */
 export function priceOf(model) {
-  const id = String(model ?? '');
-  const key = Object.keys(PRICES)
-    .filter((k) => id === k || id.startsWith(`${k}-`) || id.startsWith(`${k}[`))
-    .sort((a, b) => b.length - a.length)[0];
-  if (!key) return null;
-  const p = PRICES[key];
+  // The id itself, less the two suffixes a transcript adds to one: a context window (`[1m]`) and a snapshot
+  // date (`-20251001`). Matched by prefix, a model newer than the table was priced as the one before it —
+  // `claude-opus-5-6` as Opus 5, at five times its cache reads.
+  const id = String(model ?? '').replace(/\[[^\]]*\]$/, '').replace(/-\d{8}$/, '');
+  const p = Object.hasOwn(PRICES, id) ? PRICES[id] : null;
+  if (!p) return null;
   return { input: p.input, output: p.output, read: p.read ?? p.input * 0.1, write5m: p.input * 1.25, write1h: p.input * 2 };
 }