@xhulz/nina 0.53.3 → 0.55.0

package/src/commands/stats.mjs

@@ -459,7 +459,7 @@ const CYCLE_ENDS = { qa: 'PASS', devops: 'DEPLOYED', secops: 'SECURE' };
  * was captured under (`core`) carries it: over every round, "0 of 16 loop-backs named their issues" read
  * reports written before the rule existed as breaking it. Releases are never rewritten, so neither is this.
  */
-const RULE_SINCE = { issues: '0.22.0', stepFiles: '0.28.8' };
+const RULE_SINCE = { issues: '0.22.0', stepFiles: '0.28.8', stepLines: '0.55.0' };
 
 /**
  * Whether a round ran under a release that carries a rule. One captured before rounds recorded their pin
@@ -558,8 +558,8 @@ export function cyclesOf(records) {
  *
  * @param {object[]} records - The runs in the window.
  */
-function proportionReport(records, stepLimit = () => null) {
-  const d = proportionData(records, stepLimit);
+function proportionReport(records, stepLimit = () => null, lineLimit = () => null) {
+  const d = proportionData(records, stepLimit, lineLimit);
   if (!d) return;
   console.log(
     heading(
@@ -584,6 +584,14 @@ function proportionReport(records, stepLimit = () => null) {
       ),
     );
   }
+  if (d.overLines) {
+    console.log(
+      note(
+        `${d.overLines.count} implementer round(s) wrote more lines than one step may (${d.overLines.limit}); the largest wrote ${d.overLines.largest}. The architect forecasts a step's lines and splits it past them.`,
+        'warn',
+      ),
+    );
+  }
 }
 
 /**
@@ -593,8 +601,9 @@ function proportionReport(records, stepLimit = () => null) {
  *
  * @param {object[]} records - The rounds in the window.
  * @param {(project: string) => number|null} [stepLimit] - The most files one implementer run may write, by project.
+ * @param {(project: string) => number|null} [lineLimit] - The most lines, by project.
  */
-export function proportionData(records, stepLimit = () => null) {
+export function proportionData(records, stepLimit = () => null, lineLimit = () => null) {
   const measured = records.filter((r) => WRITERS.has(r.role) && typeof r.files_touched === 'number');
   if (measured.length === 0) return null;
   const cycles = cyclesOf(records);
@@ -629,6 +638,14 @@ export function proportionData(records, stepLimit = () => null) {
     return limit !== null && r.files_touched > limit;
   });
   const largest = over.length ? over.reduce((a, b) => (b.files_touched > a.files_touched ? b : a)) : null;
+  // And its lines: a step forecast at about 640 lines came to 2,546 in three files, under the file limit, and every
+  // gate read each of its rounds.
+  const longer = records.filter((r) => {
+    if (r.role !== 'implementer' || typeof r.lines_written !== 'number' || !ranUnder(r, 'stepLines')) return false;
+    const limit = lineLimit(r.project);
+    return limit !== null && r.lines_written > limit;
+  });
+  const longest = longer.length ? longer.reduce((a, b) => (b.lines_written > a.lines_written ? b : a)) : null;
   return {
     rows: rows.map(({ label, cycles: n, designed }) => ({ label, cycles: n, designed })),
     built,
@@ -637,18 +654,20 @@ export function proportionData(records, stepLimit = () => null) {
     over: largest
       ? { count: over.length, limit: stepLimit(largest.project), largest: largest.files_touched, readM: typeof largest.tokens?.read === 'number' ? Math.round(largest.tokens.read / 1e6) : null }
       : null,
+    overLines: longest ? { count: longer.length, limit: lineLimit(longest.project), largest: longest.lines_written } : null,
   };
 }
 
 /**
  * The most files one implementer run may write in each measured project, as its pinned release states it
  * (`{{STEP_FILES}}`, which the project may declare to change), or null where the release has no such
- * limit or the project cannot be found.
+ * limit or the project cannot be found. With `STEP_LINES`, the most lines.
  *
  * @param {{root: string}} ctx - CLI context, for the releases.
+ * @param {'STEP_FILES'|'STEP_LINES'} [key] - Which limit.
  * @returns {(project: string) => number|null}
  */
-function stepLimitOf(ctx) {
+function stepLimitOf(ctx, key = 'STEP_FILES') {
   const known = new Map();
   return (project) => {
     if (!known.has(project)) {
@@ -657,7 +676,7 @@ function stepLimitOf(ctx) {
         const found = decodeProjectDir(project);
         const profile = found ? JSON.parse(readFileSync(join(found, HARNESS, 'profile.json'), 'utf8')) : null;
         const layers = profile ? layerRootFor(ctx.root, profile.core) : null;
-        const value = profile?.vocabulary?.STEP_FILES ?? (layers?.dir ? defaultVocabulary(layers.dir).STEP_FILES : undefined);
+        const value = profile?.vocabulary?.[key] ?? (layers?.dir ? defaultVocabulary(layers.dir)[key] : undefined);
         const n = Number(value);
         limit = value !== undefined && value !== null && value !== '' && Number.isFinite(n) && n > 0 ? n : null;
       } catch {
@@ -735,7 +754,7 @@ export function statsData(records, ctx) {
     stages: stageData(records),
     cost: costData(ran),
     context: contextData(ran),
-    proportion: proportionData(ran, stepLimitOf(ctx)),
+    proportion: proportionData(ran, stepLimitOf(ctx), stepLimitOf(ctx, 'STEP_LINES')),
   };
 }
 
@@ -939,7 +958,7 @@ export async function stats(argv, ctx) {
   costReport(records.filter((r) => r.status !== 'denied'));
   contextReport(records.filter((r) => r.status !== 'denied'));
   modelReport(records.filter((r) => r.status !== 'denied'));
-  proportionReport(records.filter((r) => r.status !== 'denied'), stepLimitOf(ctx));
+  proportionReport(records.filter((r) => r.status !== 'denied'), stepLimitOf(ctx), stepLimitOf(ctx, 'STEP_LINES'));
 
   // What the pipeline learned, against what it had to learn from. A loop-back is the raw
   // material and a pill is the product, so the two numbers belong on the same screen: the

package/src/dashboard.html

@@ -308,7 +308,7 @@ const RENDER = {
         card('graduate · made rules?', `${d.open.length} open`, `${d.ready.length} at ${d.at}+ · ${d.madeHere} made a rule here${d.relapses.length ? ` · ${d.relapses.length} watched` : ''}`),
         card('loops', d.gated ? (d.activity ? String(d.activity.rounds) : '—') : 'no gate', d.activity ? `rounds on capped edges · ${d.activity.held} sent to you` : d.gated ? 'no ledger yet' : 'caps are instructions'),
       ),
-      d.late.length ? [el('h3', {}, 'capture · sent back with nothing written down'), d.late.map((o) => el('div', { class: 'note' }, el('span', { class: 'role' }, o.role), ` ${o.count} loop-back(s) ${o.since ? `since its newest lesson (${o.since})` : 'and no lesson at all'}`, el('ul', { class: 'list soft' }, o.recent.map((r) => el('li', {}, `${when(r.ts)} · ${r.desc ?? '(no description)'}`)))))] : null,
+      d.late.length ? [el('h3', {}, 'capture · sent back with nothing written down'), d.late.map((o) => el('div', { class: 'note' }, el('span', { class: 'role' }, o.role), ` sent back ${o.count} time(s) ${o.since ? `since its newest lesson (${o.since})` : 'and no lesson at all'}`, el('ul', { class: 'list soft' }, o.recent.map((r) => el('li', {}, `${when(r.ts)} · ${r.desc ?? '(no description)'}`)))))] : null,
       el('h3', {}, 'verify · is each stage sent back less since its lessons?'),
       el('p', { class: 'note soft', style: 'margin-bottom:12px' }, `For each lesson, the share of its stage's rounds that a later stage sent back, in the ${d.window} days before it was written and the ${d.window} after — lower is better. A change is called only when it is larger than chance moves a share at that many rounds. The other stages, over the same days, say whether everything moved at once: then it was the work that changed, not the lesson.`),
       groups.length ? groups.map(comparison) : el('p', { class: 'note faint' }, 'No lesson could be measured yet.'),
@@ -358,7 +358,8 @@ const RENDER = {
         table(['stage', 'rounds', 'n', 'turns', 'calls/turn', 'starts at', 'peak', 'prompt'], d.context.rows.map((r, i, all) => [i > 0 && all[i - 1].role === r.role ? '' : el('span', { class: 'role' }, r.role), el('span', { class: 'faint' }, r.label), String(r.n), String(r.turns), r.callsPerTurn.toFixed(2), kTokens(r.start), kTokens(r.peak), r.prompt === null ? '—' : r.prompt.toLocaleString('en-US')]), [2, 3, 4, 5, 6, 7])] : null,
       d.proportion ? [el('h3', {}, 'proportion · the size of a change against its chain'),
         table(['largest write', 'cycles', 'with a planner or architect', ''], d.proportion.rows.map((r) => [r.label, String(r.cycles), r.cycles ? `${r.designed} (${pct(r.designed, r.cycles)})` : '—', bar([[r.cycles ? r.designed / r.cycles : 0, 'var(--pink)']])]), [1, 2]),
-        d.proportion.over ? el('p', { class: 'note warn' }, `${d.proportion.over.count} implementer round(s) wrote more files than one step may (${d.proportion.over.limit}); the largest wrote ${d.proportion.over.largest}.`) : null] : null,
+        d.proportion.over ? el('p', { class: 'note warn' }, `${d.proportion.over.count} implementer round(s) wrote more files than one step may (${d.proportion.over.limit}); the largest wrote ${d.proportion.over.largest}.`) : null,
+        d.proportion.overLines ? el('p', { class: 'note warn' }, `${d.proportion.overLines.count} implementer round(s) wrote more lines than one step may (${d.proportion.overLines.limit}); the largest wrote ${d.proportion.overLines.largest}.`) : null] : null,
     );
   },
 };

package/src/office.html

@@ -59,7 +59,7 @@
  * drawn here, in pixels, on a small canvas scaled up; nothing is fetched from anywhere else. The view starts close
  * enough to read and follows the work around the floor; dragging, the wheel and the buttons take it over.
  */
-const ROOM = /*NINA_ROOM*/null || { project: 'demo', stages: ['planner', 'architect', 'implementer', 'reviewer', 'qa', 'dba', 'integration-tester', 'devops', 'secops'], many: ['architect', 'implementer', 'reviewer'], owner: 'you', replay: false };
+const ROOM = /*NINA_ROOM*/null || { project: 'demo', stages: ['planner', 'architect', 'design-reviewer', 'implementer', 'reviewer', 'qa', 'dba', 'integration-tester', 'devops', 'secops'], many: ['architect', 'implementer', 'reviewer'], owner: 'you', replay: false };
 
 // ─── palette and sprites ──────────────────────────────────────────────────────────────────────
 const C = {
@@ -163,7 +163,7 @@ const GARDEN = 52;
 
 /** The rooms, by phase, in the order the work moves through them. A stage not named here works in build. */
 const PHASES = [
-  { key: 'design', name: 'design', side: 'left', roles: ['planner', 'architect'] },
+  { key: 'design', name: 'design', side: 'left', roles: ['planner', 'architect', 'design-reviewer'] },
   { key: 'build', name: 'build', side: 'left', roles: ['implementer', 'solidity-dev'] },
   { key: 'review', name: 'review & gates', side: 'right', roles: ['reviewer', 'dba', 'integration-tester', 'solidity-auditor'] },
   { key: 'lab', name: 'test lab', side: 'right', roles: ['qa'] },

package/src/transcripts.mjs

@@ -75,6 +75,7 @@ const VERDICTS = [
 export const ROLE_TOKENS = {
   planner: ['PLAN-READY', 'BLOCKED'],
   architect: ['SPEC-READY', 'BLOCKED'],
+  'design-reviewer': ['APPROVED', 'REJECTED'],
   implementer: ['DIFF-READY', 'BLOCKED'],
   'solidity-dev': ['DIFF-READY', 'BLOCKED'],
   reviewer: ['APPROVED', 'REJECTED'],
@@ -120,6 +121,9 @@ export function classifyVerdict(result, role) {
 /** The tools that write a file, and where each names it. */
 const WRITES = { Edit: 'file_path', Write: 'file_path', MultiEdit: 'file_path', NotebookEdit: 'notebook_path' };
 
+/** How many lines a text written through an edit tool holds: none for an empty one, a last newline ending one. */
+const linesIn = (text) => (typeof text === 'string' && text.length > 0 ? text.replace(/\n$/, '').split('\n').length : 0);
+
 /** The line under a declared verdict that names what the report sends back. */
 const ISSUES = /^\s*ISSUES:(.*)$/;
 
@@ -642,7 +646,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 && '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 && 'effort' in r && 'turns' in r && 'prompt_chars' in r)
       ) {
         continue;
       }
@@ -670,6 +674,11 @@ async function attachAgentDetail(projectDir, dispatches) {
         usage: new Map(),
         /** The files the round wrote through the edit tools. Only their number is kept. */
         written: new Set(),
+        /**
+         * The lines it wrote there, by file: a file's last whole write, and each edit's new text after it — what the
+         * run wrote, not its diff: an edit made twice counts twice, and a file a shell command changed not at all.
+         */
+        lines: new Map(),
         /** The tool calls the round made, by id: over its turns, how many calls each turn sent at once. */
         calls: new Set(),
         /** How long the prompt that opened the round was, in characters; never the prompt. */
@@ -708,7 +717,10 @@ async function attachAgentDetail(projectDir, dispatches) {
           try {
             for (const block of JSON.parse(line)?.message?.content ?? []) {
               const path = block?.type === 'tool_use' ? block.input?.[WRITES[block.name]] : null;
-              if (typeof path === 'string') round.written.add(path);
+              if (typeof path !== 'string') continue;
+              round.written.add(path);
+              const added = { Edit: () => linesIn(block.input.new_string), MultiEdit: () => (Array.isArray(block.input.edits) ? block.input.edits : []).reduce((n, e) => n + linesIn(e?.new_string), 0), NotebookEdit: () => linesIn(block.input.new_source) }[block.name];
+              round.lines.set(path, block.name === 'Write' ? linesIn(block.input.content) : (round.lines.get(path) ?? 0) + (added?.() ?? 0));
             }
           } catch {
             // A torn line loses one edit, not the run's.
@@ -795,6 +807,7 @@ async function attachAgentDetail(projectDir, dispatches) {
           record.usage_model = spent.model;
           record.effort = spent.effort;
           record.files_touched = round.written.size;
+          record.lines_written = [...round.lines.values()].reduce((a, b) => a + b, 0);
           record.skills = [...round.skills];
           record.lessons_read = round.lessonsRead.size;
           record.lessons_listed = round.lessonsListed;