@xhulz/nina 0.69.0 → 0.71.0

package/src/transcripts.mjs

@@ -860,7 +860,7 @@ async function attachAgentDetail(projectDir, dispatches) {
       if (
         run.agent_read_bytes === size &&
         !('resumes' in run) &&
-        [...records, ...later].every((r) => settled(r) && 'round' in r && 'lessons_read' in r && 'tokens' in r && 'files_touched' in r && 'lines_written' in r && 'shell_writes' in r && 'effort' in r && 'turns' in r && 'prompt_chars' in r)
+        [...records, ...later].every((r) => settled(r) && 'round' in r && 'lessons_read' in r && 'tokens' in r && 'files_touched' in r && 'lines_written' in r && 'shell_writes' in r && 'effort' in r && 'turns' in r && 'prompt_chars' in r && 'cache_rewrites' in r && 'clipped' in r)
       ) {
         continue;
       }
@@ -899,6 +899,8 @@ async function attachAgentDetail(projectDir, dispatches) {
         calls: new Set(),
         /** How long the prompt that opened the round was, in characters; never the prompt. */
         promptChars: null,
+        /** The tool results the cost watch clipped to a file, so they were never re-read whole. */
+        clipped: 0,
       });
       const rounds = [fresh()];
       const roundOf = roundsOf();
@@ -942,6 +944,19 @@ async function attachAgentDetail(projectDir, dispatches) {
             // A torn line loses one edit, not the run's.
           }
         }
+        if (line.includes(CLIP_MARK) && line.includes('"tool_result"')) {
+          try {
+            const row = JSON.parse(line);
+            const content = row?.type === 'user' ? row.message?.content : null;
+            for (const block of Array.isArray(content) ? content : []) {
+              const said = block?.type === 'tool_result' ? block.content : null;
+              const text = typeof said === 'string' ? said : Array.isArray(said) ? said.map((x) => x?.text ?? '').join('') : '';
+              if (text.includes(CLIP_MARK)) round.clipped += 1;
+            }
+          } catch {
+            // A torn line loses one count.
+          }
+        }
         if (line.includes('"name":"Bash"')) {
           try {
             for (const block of JSON.parse(line)?.message?.content ?? []) {
@@ -1028,6 +1043,9 @@ async function attachAgentDetail(projectDir, dispatches) {
           record.tool_calls = round.calls.size;
           record.context_start = shape.start;
           record.context_peak = shape.peak;
+          record.cache_rewrites = shape.rewrites;
+          record.cache_rewritten = shape.rewritten;
+          record.clipped = round.clipped;
           record.prompt_chars = round.promptChars;
           record.usage_model = spent.model;
           record.effort = spent.effort;
@@ -1078,20 +1096,40 @@ export function promptOf(row, round) {
   return row?.type === 'user' && (round > 1 || !row.isMeta) && typeof content === 'string' ? content : null;
 }
 
+/** The smallest context whose loss counts as a rewrite: below it, a turn writing most of it is the round beginning. */
+const REWRITE_FLOOR = 30_000;
+
 /**
- * How a round spent its context: how many turns it took, and how large the context each turn re-read was
- * when the round began and at its largest. Every turn is billed the whole context again, so a round that
- * begins where a long one ended — a run resumed for a fix — pays for everything before it on each turn.
+ * How a round spent its context: how many turns it took, how large the context each turn re-read was
+ * when the round began and at its largest, and how often its cache had expired. Every turn is billed the
+ * whole context again, so a round that begins where a long one ended — a run resumed for a fix — pays for
+ * everything before it on each turn.
+ *
+ * A turn reads its context from the cache only while the cache is alive — five minutes after the turn
+ * before, for a subagent — and past that writes all of it again, at twelve times a read's price. So a turn
+ * that wrote more than half of a context of at least {@link REWRITE_FLOOR} tokens is counted a rewrite.
  *
  * @param {Map<string, {usage: object}>} usage - Message id → its final usage, in the order the round sent them.
- * @returns {{turns: number, start: number|null, peak: number|null}} Context sizes in tokens.
+ * @returns {{turns: number, start: number|null, peak: number|null, rewrites: number, rewritten: number}} Context sizes in tokens.
  */
 export function contextOf(usage) {
   const n = (v) => (typeof v === 'number' ? v : 0);
-  const sizes = [...usage.values()].map(({ usage: u }) => n(u.input_tokens) + n(u.cache_read_input_tokens) + n(u.cache_creation_input_tokens));
-  return { turns: sizes.length, start: sizes[0] ?? null, peak: sizes.length > 0 ? Math.max(...sizes) : null };
+  const turns = [...usage.values()].map(({ usage: u }) => ({ size: n(u.input_tokens) + n(u.cache_read_input_tokens) + n(u.cache_creation_input_tokens), written: n(u.cache_creation_input_tokens) }));
+  const sizes = turns.map((t) => t.size);
+  let rewrites = 0;
+  let rewritten = 0;
+  for (let i = 1; i < turns.length; i += 1) {
+    if (sizes[i - 1] >= REWRITE_FLOOR && turns[i].written > sizes[i - 1] / 2) {
+      rewrites += 1;
+      rewritten += turns[i].written;
+    }
+  }
+  return { turns: sizes.length, start: sizes[0] ?? null, peak: sizes.length > 0 ? Math.max(...sizes) : null, rewrites, rewritten };
 }
 
+/** How the cost watch opens an output it clipped (`src/cost.mjs`), which is how a snapshot counts them. */
+export const CLIP_MARK = '[NINA clipped this output';
+
 /**
  * What a run spent, from each of its messages' final usage: tokens by kind, and the model and effort
  * level that most of its messages ran at. Metadata — counts, a model id and a level, never a message.

package/src/wiring.mjs

@@ -146,6 +146,23 @@ const HOOKS = [
 /** Where a project's hooks can live: Claude Code reads both, so a hook kept in the local file counts. */
 const SETTINGS_FILES = ['.claude/settings.json', '.claude/settings.local.json'];
 
+/**
+ * Settings a project's `.claude/settings.json` carries beside its hooks, each shipped with the script whose
+ * concern it is. `why` is what `check` says when one is missing. A key the owner already wrote, in either
+ * settings file and with whatever value, is theirs: `wire` adds a missing one and never changes one.
+ *
+ * The skill listing is every installed skill's description, sized at a hundredth of the model's context
+ * window, and every stage whose tools include `Skill` re-reads it on every turn: 32k characters in two
+ * projects, a twentieth of what their stages re-read. The skills a stage must use are named in its spec,
+ * and every skill's name stays listed however small the budget, so the descriptions buy a stage nothing.
+ */
+const SETTINGS = [
+  {
+    key: 'skillListingBudgetFraction', value: 0.001, script: COST,
+    why: "every stage that may invoke a skill re-reads every installed skill's description on every turn, about 9k tokens",
+  },
+];
+
 /** The scripts some hook runs — `check` asks for these by hook, not by npm script. */
 export const HOOK_SCRIPTS = new Set(HOOKS.map((h) => h.script));
 
@@ -252,11 +269,13 @@ function covered(hooks, h) {
  *
  * @param {string} target - The project directory.
  * @param {(event: string) => boolean} [wanted] - Events whose malformed lists are worth a problem.
- * @returns {Promise<{merged: Record<string, object[]>, problems: string[]}>} Each merged group says `from` which file.
+ * @returns {Promise<{merged: Record<string, object[]>, problems: string[], keys: Set<string>}>} Each merged group says
+ *   `from` which file; `keys` holds every top-level key either file sets.
  */
 async function projectHooks(target, wanted = () => false) {
   const merged = {};
   const problems = [];
+  const keys = new Set();
   for (const rel of SETTINGS_FILES) {
     const path = join(target, rel);
     if (!existsSync(path)) continue;
@@ -267,6 +286,7 @@ async function projectHooks(target, wanted = () => false) {
       problems.push(`${rel} is not valid JSON — ${error.message}`);
       continue;
     }
+    if (settings && typeof settings === 'object' && !Array.isArray(settings)) for (const key of Object.keys(settings)) keys.add(key);
     const shape = settings?.hooks;
     if (shape === undefined || shape === null) continue;
     if (typeof shape !== 'object' || Array.isArray(shape)) {
@@ -278,7 +298,7 @@ async function projectHooks(target, wanted = () => false) {
       else if (wanted(event)) problems.push(`${rel}'s hooks.${event} is not a list — no hook in it can run`);
     }
   }
-  return { merged, problems };
+  return { merged, problems, keys };
 }
 
 /** The command settings run for a hook, when they run one — the selftest runs it the same way. */
@@ -298,7 +318,8 @@ export function hookCommand(settings, event, script) {
  * @returns {string}
  */
 export function settingsFile(shipped = HOOK_SCRIPTS) {
-  return `${JSON.stringify({ hooks: settingsHooks(HOOKS.filter((h) => shipped.has(h.script))) }, null, 2)}\n`;
+  const values = Object.fromEntries(SETTINGS.filter((x) => shipped.has(x.script)).map((x) => [x.key, x.value]));
+  return `${JSON.stringify({ ...values, hooks: settingsHooks(HOOKS.filter((h) => shipped.has(h.script))) }, null, 2)}\n`;
 }
 
 /** Hooks as settings JSON, grouped by event. */
@@ -369,8 +390,11 @@ export async function missingWiring(target, shipped) {
   }
   const wanted = HOOKS.filter((h) => shipped.has(h.script));
   if (wanted.length === 0) return out;
-  const { merged, problems } = await projectHooks(target, (event) => wanted.some((h) => h.event === event));
+  const { merged, problems, keys } = await projectHooks(target, (event) => wanted.some((h) => h.event === event));
   out.push(...problems);
+  for (const x of SETTINGS.filter((x) => shipped.has(x.script) && !keys.has(x.key))) {
+    out.push(`.claude/settings.json has no "${x.key}" — without it ${x.why}; \`nina wire --apply\` sets it to ${x.value}`);
+  }
   for (const h of wanted) {
     const running = (merged[h.event] ?? []).filter((g) => runs(g, h));
     if (doubled(running)) {
@@ -468,7 +492,11 @@ export async function applyWiring(target, shipped, { settings: editSettings = tr
     if (readable) {
       const hooks = settings.hooks ?? {};
       const added = [];
-      const { merged } = await projectHooks(target);
+      const { merged, keys } = await projectHooks(target);
+      for (const x of SETTINGS.filter((x) => shipped.has(x.script) && !keys.has(x.key))) {
+        settings[x.key] = x.value;
+        added.push(`"${x.key}": ${x.value}`);
+      }
       for (const h of HOOKS.filter((h) => shipped.has(h.script))) {
         const running = (merged[h.event] ?? []).filter((g) => runs(g, h));
         if (covered(merged, h) && !doubled(running)) continue;