@xhulz/nina 0.67.0 → 0.68.1

package/src/commands/sizes.mjs

@@ -38,6 +38,30 @@ const RATE_OVER = 5;
 /** Files a step's commit carries that are not the step's code: the harness's own, and lockfiles. */
 const NOT_CODE = /^(\.claude\/|\.nina\/|CLAUDE\.md$)|(^|\/)(pnpm-lock\.yaml|package-lock\.json|yarn\.lock|bun\.lockb?)$/;
 
+/**
+ * What a step's implementer wrote in its first round, from the `First round:` line the orchestrator writes in its step
+ * file when the step took more than one: the fix rounds after it are the review's, not the forecast's.
+ *
+ * @param {string} text - A step file.
+ * @returns {number|null}
+ */
+export function firstRoundIn(text) {
+  const m = /^[\s>*_-]*First round:[*_ \t]*~?[ \t]*(\d[\d,]*)[ \t]*lines?\b/im.exec(text);
+  return m ? Number(m[1].replace(/,/g, '')) : null;
+}
+
+/**
+ * The kind a step file says it is, from its `Kind:` line — `new`, `extends`, `tests`, or any one word a project uses:
+ * a step is measured by the steps of its kind, where any has landed.
+ *
+ * @param {string} text - A step file.
+ * @returns {string|null}
+ */
+export function kindIn(text) {
+  const m = /^[\s>*_-]*Kind:[*_ \t]*([A-Za-z][\w-]*)/m.exec(text);
+  return m ? m[1].toLowerCase() : null;
+}
+
 /**
  * The forecast a step file states, from its `Size:` line.
  *
@@ -204,13 +228,15 @@ export function measure(dir) {
   };
   const steps = [];
   for (const file of files) {
-    const now = forecastIn(readFileSync(join(dir, file.path), 'utf8'));
+    const current = readFileSync(join(dir, file.path), 'utf8');
+    const now = forecastIn(current);
+    const kind = kindIn(current);
     const landings = named.get(file.path).filter((c) => code.get(c.hash)?.size > 0);
     if (landings.length === 0) {
       if (!now) continue;
       // Forecast again in the working tree, it is newer than every commit.
       const since = at('HEAD', file.path)?.lines === now.lines ? writtenAt(file.path, Infinity, now.lines) : Infinity;
-      steps.push({ ...file, landed: false, forecast: now, since });
+      steps.push({ ...file, kind, landed: false, forecast: now, since });
       continue;
     }
     // The forecast the step was built to: its file before its first commit, or as that commit wrote it.
@@ -225,15 +251,22 @@ export function measure(dir) {
     const last = landings.at(-1);
     // A forecast changed while the step was built — a fix round's spec — is shown, and the step measured against the first.
     const revised = at(last.hash, file.path);
+    const firstRound = firstRoundIn(current);
+    const ratio = total / forecast.lines;
     steps.push({
       ...file,
+      kind,
       landed: true,
       forecast,
       revised: revised && revised.lines !== forecast.lines ? revised : null,
       since,
       lines: total,
       files: lines.size,
-      ratio: total / forecast.lines,
+      ratio,
+      first: firstRound,
+      // What the forecast missed by: its first round where the step file says it, so fix rounds do not compound into
+      // the rate one correction-heavy step at a time.
+      measured: firstRound === null ? ratio : firstRound / forecast.lines,
       t: last.t,
       at: last.at,
       hash: last.hash,
@@ -243,37 +276,41 @@ export function measure(dir) {
 }
 
 /**
- * The rate to forecast a step again at: the median actual over forecast of its spec's newest landed steps forecast no
- * earlier than it was. A step forecast before the last re-forecast was measured against the old rates, which that
- * re-forecast already corrected for, and counting it would correct for them twice.
+ * The rate to forecast a step again at: the median of what its spec's newest landed steps forecast no earlier than it
+ * missed by (`measured`), over the steps of its kind where any has landed. A step forecast before the last re-forecast
+ * was measured against the old rates, which that re-forecast already corrected for, and counting it would correct for
+ * them twice; and a new module's rate put on steps that extend an existing file asked one project for six splits.
  *
  * @param {object[]} steps
- * @param {{spec: string, since?: string}} step - Its spec, and when its own forecast was written.
- * @returns {{rate: number, over: number}|null}
+ * @param {{spec: string, since?: string, kind?: string|null}} step - Its spec, when its own forecast was written, its kind.
+ * @returns {{rate: number, over: number, kind: string|null}|null}
  */
-export function rateOf(steps, { spec, since }) {
+export function rateOf(steps, { spec, since, kind = null }) {
   // A forecast not known to be written when is measured by nothing, rather than by everything.
   if (since === null || since === undefined) return null;
-  const landed = steps
-    .filter((s) => s.landed && s.spec === spec && s.since >= since)
-    .sort((a, b) => a.t - b.t)
-    .slice(-RATE_OVER);
-  return landed.length ? { rate: median(landed.map((s) => s.ratio)), over: landed.length } : null;
+  const landed = steps.filter((s) => s.landed && s.spec === spec && s.since >= since).sort((a, b) => a.t - b.t);
+  const mine = kind ? landed.filter((s) => s.kind === kind) : [];
+  const over = (mine.length ? mine : landed).slice(-RATE_OVER);
+  return over.length ? { rate: median(over.map((s) => s.measured ?? s.ratio)), over: over.length, kind: mine.length ? kind : null } : null;
 }
 
 /**
  * What the detector says: the newest landed step, when it overran, and the steps of its spec still forecast as they
- * were when it landed.
+ * were when it landed — until one of them is forecast again. The next step to go out is forecast again at its turn, and
+ * the rest at theirs: asked for every one at once, one project was asked for twenty splits of steps three or more
+ * steps away, which later steps would each have measured again.
  *
- * @param {string} dir
- * @param {{steps: object[], limit: number}} measured
- * @returns {{step: object, rate: {rate: number, over: number}, stale: object[]}|null}
+ * @param {{steps: object[]}} measured
+ * @returns {{step: object, rate: {rate: number, over: number, kind: string|null}, stale: object[]}|null}
  */
 export function overrun({ steps }) {
   const newest = steps.filter((s) => s.landed).sort((a, b) => a.t - b.t).at(-1);
-  if (!newest || newest.ratio <= OVERRUN) return null;
+  if (!newest || newest.measured <= OVERRUN) return null;
+  const mine = steps.filter((s) => !s.landed && s.spec === newest.spec && s.since !== null);
+  // A step forecast since it landed is the one about to go out, forecast at its turn: the overrun was acted on.
+  if (mine.some((s) => s.since > newest.t)) return null;
   // Forecast no later than the overrun step was, so its rate measures them: forecast again since, they are not stale.
-  const stale = steps.filter((s) => !s.landed && s.spec === newest.spec && s.since !== null && s.since <= newest.since);
+  const stale = mine.filter((s) => s.since <= newest.since);
   return stale.length ? { step: newest, rate: rateOf(steps, stale[0]), stale } : null;
 }
 
@@ -312,15 +349,17 @@ export async function sizes(argv) {
       console.log('sizes: current');
       return 0;
     }
-    const { step, rate, stale } = found;
+    const { step, stale } = found;
     const again = stale.slice(0, 4).map((s) => {
-      const next = Math.round(s.forecast.lines * rate.rate);
-      return `${s.step} ~${s.forecast.lines} → ~${next}${next > limit ? ` (past ${limit}: split)` : ''}`;
+      const rate = rateOf(steps, s);
+      const next = Math.round(s.forecast.lines * (rate?.rate ?? 1));
+      return `${s.step} ~${s.forecast.lines} → ~${next}${rate?.kind ? ` (${rate.kind})` : ''}${next > limit ? ` past ${limit}` : ''}`;
     });
+    const first = step.first === null ? '' : `, ${step.first} in its first round (${times(step.measured)})`;
     console.log(
-      `step ${step.step} of ${step.spec} landed ${step.lines} lines against ~${step.forecast.lines} (${times(step.ratio)}); ` +
-        `${stale.length} step(s) forecast when it was have not been forecast again — at ${times(rate.rate)}, over ${rate.over} landed step(s) forecast the same way: ` +
-        `${again.join(', ')}${stale.length > again.length ? ', …' : ''}`,
+      `step ${step.step} of ${step.spec} landed ${step.lines} lines against ~${step.forecast.lines} (${times(step.ratio)}${first}); ` +
+        `before the next of its ${stale.length} step(s) forecast when it was goes out, forecast that one again — a \`Size:\` line at the rate \`nina sizes\` gives it — ` +
+        `and split it if that puts it past ${limit}; the rest at their turn: ${again.join(', ')}${stale.length > again.length ? ', …' : ''}`,
     );
     return 1;
   }
@@ -332,10 +371,13 @@ export async function sizes(argv) {
     const mine = steps.filter((s) => s.spec === spec);
     console.log(`\n  ${bold(pink(spec))}${dim(`  landed against the forecast it was built to; limit ${limit} lines`)}`);
     for (const s of mine.filter((x) => x.landed).sort((a, b) => a.t - b.t)) {
-      const mark = s.ratio > OVERRUN ? amber(times(s.ratio)) : times(s.ratio);
+      const mark = s.measured > OVERRUN ? amber(times(s.ratio)) : times(s.ratio);
       const files = s.forecast.files === null ? `${s.files} file(s)` : `${s.files} file(s) of ${s.forecast.files}`;
-      const revised = s.revised ? `, revised to ~${s.revised.lines} while built` : '';
-      console.log(`    ${s.step.padEnd(10)} ~${String(s.forecast.lines).padEnd(5)} → ${String(s.lines).padEnd(5)} ${mark}  ${dim(`${files}${revised} · ${s.hash.slice(0, 7)} ${s.at.slice(0, 10)}`)}`);
+      // Against a forecast revised while it was built too, so a project can tell a forecasting miss from correction rounds.
+      const revised = s.revised ? `, revised to ~${s.revised.lines} while built: ${times(s.lines / s.revised.lines)} against it` : '';
+      const first = s.first === null ? '' : `, first round ${s.first} ${times(s.measured)}`;
+      const kind = s.kind ? `${s.kind} · ` : '';
+      console.log(`    ${s.step.padEnd(10)} ~${String(s.forecast.lines).padEnd(5)} → ${String(s.lines).padEnd(5)} ${mark}  ${dim(`${kind}${files}${first}${revised} · ${s.hash.slice(0, 7)} ${s.at.slice(0, 10)}`)}`);
     }
     for (const s of mine.filter((x) => !x.landed)) {
       const rate = rateOf(steps, s);
@@ -346,7 +388,7 @@ export async function sizes(argv) {
       const next = Math.round(s.forecast.lines * rate.rate);
       console.log(
         `    ${s.step.padEnd(10)} ~${String(s.forecast.lines).padEnd(5)} → ~${String(next).padEnd(5)} ` +
-          dim(`to land, at ${times(rate.rate)} over ${rate.over} step(s) forecast as it was`) +
+          dim(`to land, at ${times(rate.rate)} over ${rate.over} ${rate.kind ? `${rate.kind} ` : ''}step(s) forecast as it was`) +
           (next > limit ? amber(`  past ${limit}: split`) : ''),
       );
     }

package/src/gate.mjs

@@ -399,8 +399,9 @@ export function replay(entries, loops, forward = new Map()) {
 
   entries.forEach((e, i) => {
     if (e.k === 'reset') {
-      // Ledgers written before the model's own questions stopped counting as the owner speaking hold those too.
-      if (e.why === 'ask') return;
+      // Ledgers written before the model's own questions stopped counting as the owner speaking hold those too. The
+      // prompt that opens a session carrying loops over is the owner resuming the work, not answering a loop.
+      if (e.why === 'ask' || e.why === 'resume') return;
       for (const key of streak.keys()) if (key.split('|').length === 2) grace.set(key, (grace.get(key) ?? 0) + 1);
       return;
     }
@@ -441,7 +442,7 @@ export function replay(entries, loops, forward = new Map()) {
       for (const r of rounds) {
         streak.set(r.key, { n: r.edgeRound, agents: r.agents, at: r.at, blind: r.blind });
         for (const issue of r.issues ?? []) streak.set(`${r.key}|${issue.id}`, { n: issue.round, edge: r.edgeRound });
-        made.push({ ...r, at: e.at });
+        made.push({ ...r, at: e.at, index: i, ...(e.inherited ? { inherited: e.inherited } : {}) });
       }
     }
   });
@@ -460,7 +461,7 @@ export function replay(entries, loops, forward = new Map()) {
       const onward = [...forward].filter(([, sources]) => sources.has(source)).map(([stage]) => stage);
       return { source, token, rounds: s.n, cap, given: grace.get(key) ?? 0, issues, closing, targets: [...targetsOf(source)], onward };
     });
-  const waiting = [...pending.entries()].flatMap(([source, batch]) => batch.filter((v) => isLoopBack(v.verdict)).map((v) => ({ source, verdict: v.verdict, issues: v.issues ?? [] })));
+  const waiting = [...pending.entries()].flatMap(([source, batch]) => batch.filter((v) => isLoopBack(v.verdict)).map((v) => ({ source, verdict: v.verdict, issues: v.issues ?? [], index: v.at })));
   return { effect: (to) => effect(to, entries.length), rounds: made, open, waiting };
 }
 
@@ -913,12 +914,104 @@ export function loopState(project, entries) {
   }
   for (const w of waiting) lines.push(`- waiting on a fix: ${w.source} ${w.verdict}${w.issues.length ? `, issues ${w.issues.join(', ')}` : ''}`);
   if (open.length === 0 && waiting.length === 0) lines.push('- no loop is open');
-  const dispatched = entries.filter((e) => e.k === 'dispatch' && e.role).slice(-4);
+  const dispatched = entries.filter((e) => e.k === 'dispatch' && e.role && !e.inherited).slice(-4);
   if (dispatched.length) lines.push(`- the latest dispatches: ${dispatched.map((e) => e.role).join(', ')}, the newest at ${String(dispatched.at(-1).at ?? '').slice(11, 16)} UTC`);
   const closing = open.filter((l) => l.closing).length;
   return { lines, open: open.length - closing, closing, waiting: waiting.length };
 }
 
+/** The entries a replay reads, and so the ones a session carries over from the one before it. */
+const REPLAYED = new Set(['pre', 'dispatch', 'verdict', 'reset']);
+
+/**
+ * How long the latest earlier session must have been quiet for a new one to carry its loops over: written to within
+ * the last minute, it is still at work, and a session the selftest begins milliseconds after another is not its sequel.
+ */
+const QUIET_MS = 60_000;
+
+/**
+ * A new session's ledger begins with the loops the project's latest earlier session left open: the ledger is a
+ * session's, so a loop open when its session ended was not open in the next, and its cap started over. Work that
+ * pauses with a handoff note and resumes in a new session paused one design loop at round 1 of 2, and the next
+ * session's gate would have let it make two more. What is carried over is the earlier ledger's own entries from the
+ * launch whose rejection began the oldest loop still open, marked `inherited` with the session they came from, so
+ * the replay counts them as it counted them there; the office and `learn` leave them to the session that wrote them.
+ * A session running beside this one in the same checkout is carried over too: its loops are counted here as well,
+ * which holds a cap tighter, never looser.
+ *
+ * @param {string} root - The project.
+ * @param {object} project - `loadProject`'s.
+ * @param {string} path - This session's ledger, not written yet.
+ * @param {string} at - Now.
+ * @returns {{from: string, lines: string[]}|null} What was carried over, said as `nina gate --status` says it.
+ */
+function inherit(root, project, path, at) {
+  const session = basename(path, '.jsonl');
+  const earlier = sessionLedgers(root).ledgers.find((l) => l.session !== session);
+  if (!earlier || Date.parse(at) - earlier.written.getTime() < QUIET_MS) return null;
+  const entries = readLedger(earlier.path);
+  const { open, waiting, rounds } = replay(entries, project.loops, project.forward);
+  const held = open.filter((l) => !l.closing);
+  if (held.length === 0 && waiting.length === 0) return null;
+  // Where each began: the launch of its source before the dispatch that made its first round since it last closed,
+  // or before the rejection a fix still waits on — so its rejection, its fix and every round after it come along. A
+  // launch is where its `pre` stands: a foreground run's `dispatch` is written after its verdict, and cut there the
+  // rejection that began the loop stayed behind.
+  const launchBefore = (source, index) => {
+    const j = entries.findLastIndex((e, k) => k < index && (e.k === 'pre' || e.k === 'dispatch') && e.role === source);
+    const pre = j >= 0 && entries[j].k === 'dispatch' && entries[j].id ? entries.findIndex((e, k) => k < j && e.k === 'pre' && e.id === entries[j].id) : -1;
+    return pre >= 0 ? pre : j;
+  };
+  const starts = [
+    ...held.map((l) => {
+      const first = rounds.findLast((r) => r.key === `${l.source}|${l.token}` && r.edgeRound === 1);
+      return first ? launchBefore(l.source, first.index) : 0;
+    }),
+    ...waiting.map((w) => launchBefore(w.source, w.index)),
+  ];
+  const from = Math.max(0, Math.min(...starts));
+  const carried = entries.slice(from).filter((e) => REPLAYED.has(e.k));
+  mkdirSync(dirname(path), { recursive: true });
+  const head = { k: 'inherit', at, from: earlier.session, loops: held.length, waiting: waiting.length };
+  try {
+    writeFileSync(path, [head, ...carried.map((e) => ({ ...e, inherited: e.inherited ?? earlier.session }))].map((e) => `${JSON.stringify(e)}\n`).join(''), { flag: 'wx' });
+  } catch (error) {
+    // Two of this session's hooks at once: the other carried them over.
+    if (error?.code === 'EEXIST') return null;
+    throw error;
+  }
+  const lines = loopState(project, [head, ...carried]).lines.filter((line) => !line.startsWith('- the latest dispatches'));
+  return { from: earlier.session, lines };
+}
+
+/**
+ * What a session that carried loops over still owes its first prompt, when another event began its ledger: that prompt
+ * resumes the work, and is told what was carried. Read only where the ledger opens with what was carried.
+ *
+ * @param {object} project - `loadProject`'s.
+ * @param {string} path - The session's ledger.
+ * @returns {{from: string, lines: string[]}|null}
+ */
+function owedResume(project, path) {
+  let head = null;
+  try {
+    const fd = openSync(path, 'r');
+    try {
+      const buffer = Buffer.alloc(512);
+      const read = readSync(fd, buffer, 0, buffer.length, 0);
+      head = JSON.parse(buffer.toString('utf8', 0, read).split('\n')[0]);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+  if (head?.k !== 'inherit') return null;
+  const entries = readLedger(path);
+  if (entries.some((e) => e.k === 'reset' && !e.inherited)) return null;
+  return { from: String(head.from ?? ''), lines: loopState(project, entries).lines.filter((line) => !line.startsWith('- the latest dispatches')) };
+}
+
 /**
  * What the gate hands the orchestrator after its conversation was compacted: the loops still open and the
  * loop-backs waiting on a fix, the latest dispatches, where the checkout stands, and the two documents to read
@@ -992,15 +1085,28 @@ export function handle(input, { root, now = new Date(), pkg = PACKAGE }) {
     if (!project) return null;
     const path = ledgerPath(root, input?.session_id);
     const at = now.toISOString();
+    // A session's first event: its ledger begins with the loops the one before it left open. A carry-over that fails
+    // costs only itself, never the event's own work.
+    let carried = null;
+    try {
+      carried = input?.session_id && !existsSync(path) ? inherit(root, project, path, at) : null;
+    } catch (error) {
+      logError(root, input?.hook_event_name, error, now);
+    }
     switch (input?.hook_event_name) {
-      case 'UserPromptSubmit':
+      case 'UserPromptSubmit': {
         if (typeof input.prompt === 'string' && DELIVERED.test(input.prompt.slice(0, DELIVERY_HEAD))) {
           const from = /<agent-message from="([^"]+)"/.exec(input.prompt)?.[1] ?? /<task-id>([^<\s]+)<\/task-id>/.exec(input.prompt)?.[1];
           return leftBehind(input, project, path, at, from, 'UserPromptSubmit');
         }
-        append(path, { k: 'reset', at, why: 'prompt' });
+        // The session's first prompt, whatever event began its ledger.
+        const resumed = carried ?? owedResume(project, path);
+        append(path, { k: 'reset', at, why: resumed ? 'resume' : 'prompt' });
         prune(root, now);
-        return null;
+        if (!resumed) return null;
+        const said = [`The NINA loop gate carried over what session ${resumed.from.slice(0, 8)} left open; its caps hold here as they did there:`, ...resumed.lines];
+        return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: said.join('\n') } };
+      }
       case 'SubagentStop':
         return onStop(input, project, path, at);
       case 'SessionStart':