@xhulz/nina 0.35.0 → 0.37.0

package/src/gate.mjs

@@ -9,15 +9,15 @@
  * the verdict a dispatch answers may not be on disk when the dispatch is about to go out, and the file
  * is mostly replay: a session resumed over a bridge rewrites its history, three quarters of the bytes
  * in the one measured. The gate keeps its own ledger instead — one small file per session, metadata
- * only, with the ids a report gave its issues as the one thing a model wrote — written by the hooks
+ * only, with the ids a report gave its issues and the name an agent was launched with as the only things a
+ * model wrote — written by the hooks
  * that see each fact as it happens:
  *
  *   PostToolUse on SubagentHandback   the report a stage handed back, verbatim — its verdict
  *   SubagentStop                      the same, for a stage that wrote its report as its last message
  *   PreToolUse / PostToolUse on Agent, Task, SendMessage
  *                                     a dispatch launched, and the agent it launched
- *   UserPromptSubmit (human text only), an AskUserQuestion answer
- *                                     the owner spoke, and every count starts over
+ *   UserPromptSubmit (human text only) the owner spoke, and every open loop gets one round more
  *   PreToolUse on Agent, Task, SendMessage
  *                                     the decision: let it through, or send the round past the cap to
  *                                     the owner to confirm
@@ -41,7 +41,13 @@
  * belongs to that round; a pass cancels a rejection only if a fix went out between the two — a later
  * review that saw the fix — and closes the loop only if it began after the latest fix with no rejection
  * running beside it; a pass from the stage the source hands its work on to (qa, after the reviewer)
- * closes the source's loops; and the owner speaking empties everything. Guessed verdicts never count.
+ * closes the source's loops; and the owner speaking gives every loop still open one round more than its cap —
+ * it used to empty everything, and since the owner speaks every few minutes no loop ever reached a cap: over
+ * two days of one project, sixty resets and not one question. Guessed verdicts never count.
+ *
+ * A loop is its source's verdict, whichever stage the orchestrator sends the fix to: a rejection routed to
+ * the architect one round and to the implementer the next was counted once on each edge, and went round
+ * twice its cap before anything asked. Each edge's own cap still decides the round that goes to it.
  *
  * It fails open, and it only acts where the project pins a version that ships it. Any error lets the
  * call through and is logged where `nina gate --selftest`, a detector every project runs, reports it: a
@@ -53,7 +59,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { TERMINALS, declaredTokens, parseGraph } from './graph.mjs';
 import { gateDir, slugFor } from './paths.mjs';
-import { declaredIssues, isLoopBack } from './transcripts.mjs';
+import { declaredIssues, isLoopBack, saidToAgent } from './transcripts.mjs';
 
 /** The package this runs from: its releases say whether a pinned version ships the gate at all. */
 const PACKAGE = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -266,7 +272,9 @@ function append(path, entry) {
  *   too, the round's number is its most-repeated issue's instead — one more than the rounds that issue
  *   was in since then — and the edge's own number is kept beside it, against a ceiling of twice the cap.
  *   A late sibling's issues are counted in the round it belongs to;
- * - a pass from the stage the source hands passing work on to closes the source's loops outright.
+ * - a pass from the stage the source hands passing work on to closes the source's loops outright;
+ * - the owner speaking gives each loop still open one round more — its `grace` — and closes nothing. A
+ *   model's own question to the owner (`AskUserQuestion`) is not the owner speaking.
  *
  * @param {object[]} entries - The ledger, oldest first.
  * @param {ReturnType<typeof loopEdges>} loops - The capped loop-back edges.
@@ -307,6 +315,8 @@ export function replay(entries, loops, forward = new Map()) {
    * @type {Map<string, {n: number, agents?: string[], at?: number, blind?: boolean, edge?: number}>}
    */
   const streak = new Map();
+  /** `${source}|${token}` → the rounds the owner has given the loop past its cap, by speaking while it was open. */
+  const grace = new Map();
   /** Where each source's latest round went out: a pass must begin after it to say the fix passed. */
   const lastFix = new Map();
   /** Completions a dispatch already acted on: a late copy of one is not new. */
@@ -315,7 +325,7 @@ export function replay(entries, loops, forward = new Map()) {
   const reportedAt = new Map();
   const made = [];
   const close = (source) => {
-    for (const key of [...streak.keys()]) if (key.startsWith(`${source}|`)) streak.delete(key);
+    for (const map of [streak, grace]) for (const key of [...map.keys()]) if (key.startsWith(`${source}|`)) map.delete(key);
   };
 
   const effect = (to, at) => {
@@ -329,7 +339,7 @@ export function replay(entries, loops, forward = new Map()) {
       const closes = passes.some((p) => p.launch > (lastFix.get(source) ?? -1) && !live.some((v) => v.launch < p.at));
       const routed = live.filter((v) => byToken.get(v.verdict)?.has(to));
       const fresh = routed.filter((v) => {
-        const last = streak.get(`${source}|${to}|${v.verdict}`);
+        const last = streak.get(`${source}|${v.verdict}`);
         return closes || !last || v.launch > last.at;
       });
       // A late sibling belongs to the round it was running in, so its issues do too: each is counted in
@@ -338,7 +348,7 @@ export function replay(entries, loops, forward = new Map()) {
       const adopted = new Map();
       const blinded = new Set();
       for (const v of routed.filter((r) => !fresh.includes(r))) {
-        const key = `${source}|${to}|${v.verdict}`;
+        const key = `${source}|${v.verdict}`;
         const edge = streak.get(key);
         if (!edge) continue;
         if (!(v.issues?.length > 0)) blinded.add(key);
@@ -349,21 +359,22 @@ export function replay(entries, loops, forward = new Map()) {
       }
       if (fresh.length > 0) {
         const token = fresh.at(-1).verdict;
-        const key = `${source}|${to}|${token}`;
-        const max = byToken.get(token).get(to);
+        const key = `${source}|${token}`;
+        const given = grace.get(key) ?? 0;
+        const max = byToken.get(token).get(to) + given;
         const before = closes ? { n: 0, agents: [] } : (streak.get(key) ?? { n: 0, agents: [] });
         const agents = [...new Set([...(before.agents ?? []), ...fresh.map((v) => v.agent)])];
         // Counted by issue only while every round since the loop last closed named its issues: a round
         // that named nothing advanced no issue's count, so from then on only the edge's count is whole.
         const named = !before.blind && !blinded.has(key) && fresh.every((v) => v.issues?.length > 0);
-        const round = { key, source, target: to, token, round: before.n + 1, max, edgeRound: before.n + 1, ceiling: max, blind: !named, agents, at };
+        const round = { key, source, target: to, token, round: before.n + 1, max, edgeRound: before.n + 1, ceiling: max, blind: !named, agents, at, given };
         if (named) {
           const issues = [...new Set(fresh.flatMap((v) => v.issues))].map((id) => ({
             id,
             round: (closes ? 0 : ((adopted.get(`${key}|${id}`) ?? streak.get(`${key}|${id}`))?.n ?? 0)) + 1,
           }));
           const worst = issues.reduce((a, b) => (b.round > a.round ? b : a));
-          Object.assign(round, { round: worst.round, issue: worst.id, issues, ceiling: max * EDGE_CEILING });
+          Object.assign(round, { round: worst.round, issue: worst.id, issues, ceiling: (max - given) * EDGE_CEILING + given });
         }
         rounds.push(round);
       }
@@ -374,9 +385,9 @@ export function replay(entries, loops, forward = new Map()) {
 
   entries.forEach((e, i) => {
     if (e.k === 'reset') {
-      pending.clear();
-      streak.clear();
-      lastFix.clear();
+      // Ledgers written before the model's own questions stopped counting as the owner speaking hold those too.
+      if (e.why === 'ask') return;
+      for (const key of streak.keys()) if (key.split('|').length === 2) grace.set(key, (grace.get(key) ?? 0) + 1);
       return;
     }
     if (e.k === 'verdict' && e.declared && e.agent) {
@@ -463,25 +474,25 @@ function withoutRef(to) {
 }
 
 /**
- * Who a SendMessage goes to: an agent id the ledger has seen, or — since the tool tells the model to
- * prefer names — a name, which in this pipeline is the stage's own, with or without the ` [ref]` a
- * listing appends.
+ * Who a SendMessage goes to: an agent id the ledger has seen, or a name, with or without the ` [ref]` a
+ * listing appends. A name is the one an agent was launched with, or — launched with none — its stage's; and,
+ * as Claude Code resolves it, the latest agent to go by it is the one reached. A fixer launched as `fixer` and
+ * resumed by that name was seen only after it went out, so no resume of it was ever asked about.
  *
  * @returns {{agent: string|null, role: string|null}}
  */
 function recipient(entries, project, to) {
-  const agent = withoutRef(to) || null;
-  const role = roleOf(entries, agent) ?? (agent && project.graph.stages.has(agent) ? agent : null);
+  const said = withoutRef(to) || null;
+  const goesBy = (e) => e.name ?? (e.via === 'SendMessage' ? null : e.role);
+  const named = said ? entries.findLast((e) => e.k === 'dispatch' && e.agent && goesBy(e) === said) : null;
+  const agent = named?.agent ?? said;
+  const role = roleOf(entries, agent) ?? (said && project.graph.stages.has(said) ? said : null);
   return { agent, role };
 }
 
-/** Where this agent's current completion starts in the ledger: after its latest launch. */
+/** Where this agent's current completion starts in the ledger: after its latest launch. A `pre` names no agent. */
 function currentLaunch(entries, agent) {
-  let at = -1;
-  entries.forEach((e, i) => {
-    if ((e.k === 'dispatch' || e.k === 'pre') && e.agent === agent) at = i;
-  });
-  return at;
+  return entries.findLastIndex((e) => e.k === 'dispatch' && e.agent === agent);
 }
 
 /**
@@ -513,8 +524,10 @@ function handbackIn(path) {
       continue;
     }
     const content = row?.message?.content;
-    // A new prompt — the resume of a finished agent — starts a new completion; its handback is later.
-    if (row?.type === 'user' && (typeof content === 'string' || (Array.isArray(content) && content.some((b) => b?.type === 'text')))) message = null;
+    // A new prompt — the resume of a finished agent — starts a new completion; its handback is later. What
+    // counts as one is the parser's: a reminder Claude Code slips in after the handback is not, and read as one
+    // it threw away the handback the stop was looking for.
+    if (saidToAgent(row)) message = null;
     if (!Array.isArray(content)) continue;
     for (const block of content) {
       if (block?.type === 'tool_use' && block.name === 'SubagentHandback' && typeof block.input?.message === 'string') message = block.input.message;
@@ -566,10 +579,6 @@ function onPost(input, project, path, at) {
   }
   // A dispatch made inside a subagent is not the pipeline's: its stages are dispatched by the orchestrator.
   if (input.agent_id) return null;
-  if (tool === 'AskUserQuestion') {
-    append(path, { k: 'reset', at, why: 'ask' });
-    return null;
-  }
   if (!DISPATCH.has(tool)) return null;
   const response = input.tool_response && typeof input.tool_response === 'object' ? input.tool_response : {};
   let role;
@@ -584,7 +593,9 @@ function onPost(input, project, path, at) {
   }
   if (!role || !project.graph.stages.has(role)) return null;
   const resumed = tool === 'SendMessage' ? Boolean(response.resumedAgentId) : undefined;
-  append(path, { k: 'dispatch', at, role, agent, via: tool, id: input.tool_use_id ?? null, ...(resumed === undefined ? {} : { resumed }) });
+  // The name an agent was launched with, if any: a later SendMessage may reach it by that name alone.
+  const name = tool !== 'SendMessage' && typeof input.tool_input?.name === 'string' ? input.tool_input.name.slice(0, 80) : null;
+  append(path, { k: 'dispatch', at, role, agent, via: tool, id: input.tool_use_id ?? null, ...(name ? { name } : {}), ...(resumed === undefined ? {} : { resumed }) });
   return null;
 }
 
@@ -599,9 +610,10 @@ const excess = (r) => Math.max(r.round - r.max, r.edgeRound - r.ceiling);
 function confirmation(r) {
   const from = r.agents.length > 0 ? ` The rounds so far came from ${r.agents.join(', ')}.` : '';
   const edge = `${r.source} → ${r.target} (${r.token})`;
-  let why = `this would be round ${r.round} on ${edge}, and .claude/graph.md caps that loop at ${r.max}.`;
+  const cap = r.given ? `${r.max - r.given}, and your ${r.given} repl${r.given === 1 ? 'y' : 'ies'} since it opened gave it ${r.given} more` : `${r.max}`;
+  let why = `this would be round ${r.round} on ${edge}, and .claude/graph.md caps that loop at ${cap}.`;
   if (r.issue && r.round > r.max) {
-    why = `this would be round ${r.round} of the issue \`${r.issue}\` on ${edge}, and .claude/graph.md caps that loop at ${r.max}.`;
+    why = `this would be round ${r.round} of the issue \`${r.issue}\` on ${edge}, and .claude/graph.md caps that loop at ${cap}.`;
   } else if (r.issue) {
     why =
       `this would be round ${r.edgeRound} on ${edge} with no approval between them. No issue has passed the cap of ${r.max}, ` +

package/src/graph.mjs

@@ -158,8 +158,44 @@ export function validateGraph(graph, specs, roles = new Set()) {
     if (isLoopBack(e.token) && !TERMINALS.has(e.to) && e.max === null) {
       problems.push(`graph.md:${e.line}: loop-back \`${e.from}\` → \`${e.to}\` has no cap — add "· max N"`);
     }
+    // A cap of none sends every round to the owner: the edge is one to `human`, said another way.
+    if (e.max !== null && e.max < 1) problems.push(`graph.md:${e.line}: \`${e.from}\` → \`${e.to}\` is capped at ${e.max} — a cap is one round or more`);
+    if (TERMINALS.has(e.from)) problems.push(`graph.md:${e.line}: an edge leaves \`${e.from}\`, where work ends`);
   }
 
+  // The shape of the whole. Each of these held in every graph composed so far and nothing checked it: a
+  // cycle through verdicts that pass work on has no cap and never ends; a stage no edge touches is never
+  // dispatched; and one from which no chain of edges reaches `done` or `human` is where work stops unseen.
+  const forward = new Map();
+  for (const e of edges) if (!isLoopBack(e.token) && stages.has(e.from) && stages.has(e.to)) forward.set(e.from, [...(forward.get(e.from) ?? []), e.to]);
+  const state = new Map();
+  const cycle = (stage, path) => {
+    state.set(stage, 'open');
+    for (const next of forward.get(stage) ?? []) {
+      if (state.get(next) === 'open') return [...path.slice(path.indexOf(next)), next];
+      if (!state.has(next)) {
+        const found = cycle(next, [...path, next]);
+        if (found) return found;
+      }
+    }
+    state.set(stage, 'done');
+    return null;
+  };
+  for (const s of stages) {
+    const found = state.has(s) ? null : cycle(s, [s]);
+    if (found) {
+      problems.push(`the graph goes round ${found.map((x) => `\`${x}\``).join(' → ')} on verdicts that pass work on — a loop with no cap`);
+      break;
+    }
+  }
+  for (const s of stages) if (!edges.some((e) => e.from === s || e.to === s)) problems.push(`stage \`${s}\` has no edge in or out — nothing dispatches it`);
+  const ends = new Set(TERMINALS);
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const e of edges) if (ends.has(e.to) && !ends.has(e.from)) grew = ends.add(e.from) && true;
+  }
+  for (const s of stages) if (edges.some((e) => e.from === s) && !ends.has(s)) problems.push(`no chain of edges from \`${s}\` reaches \`done\` or \`human\` — work there never ends`);
+
   // The loop gate reads one cap per edge. Two lines naming the same edge with different caps would
   // leave it guessing which one holds; it would take the larger, but a graph should not need a
   // tie-breaker.

package/src/store.mjs

@@ -0,0 +1,158 @@
+/**
+ * The measurement store, read one way by every report.
+ *
+ * Five readers each parsed `~/.nina/snapshots/<project>.jsonl` their own way — `stats`, `runs`, `learn`,
+ * `export` and `status` — and chose the project four different ways, so two reports on the same history
+ * disagreed and neither said why. Every report reads it here now. Only `snapshot`, which rewrites the file,
+ * reads it raw.
+ */
+
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { slugFor, snapshotsDir } from './paths.mjs';
+import { ROLE_TOKENS } from './transcripts.mjs';
+
+/** What a record says when no verdict was read from its report. */
+const UNREAD = new Set(['UNCLEAR', 'NONE', null, undefined]);
+
+/**
+ * Records from a store file's text. A torn line loses one record, never the file.
+ *
+ * @param {string} text - The file.
+ * @returns {object[]}
+ */
+export function parseStore(text) {
+  return String(text)
+    .split('\n')
+    .filter((l) => l.trim())
+    .flatMap((l) => {
+      try {
+        return [JSON.parse(l)];
+      } catch {
+        return [];
+      }
+    });
+}
+
+/**
+ * A record as the reports read it. A verdict outside the vocabulary of the role that gave it is not a
+ * verdict that role can give: records captured before the classifier knew the role read a dba's report
+ * as `PASS`, qa's token, and 21 of those made a gate that had stopped one change in fourteen look like a
+ * rubber stamp. Kept in the store as captured, and read as unreadable.
+ *
+ * @param {object} record - As captured.
+ * @returns {object}
+ */
+export function asRead(record) {
+  const tokens = ROLE_TOKENS[record?.role];
+  if (!tokens || UNREAD.has(record.verdict) || tokens.includes(record.verdict)) return record;
+  return { ...record, verdict: 'UNCLEAR', verdict_source: 'outside-role' };
+}
+
+/**
+ * Every record in one store file.
+ *
+ * @param {string} file - The file.
+ * @param {{raw?: boolean}} [options] - `raw`: as captured, for the one writer of the store.
+ * @returns {object[]} Empty when there is no such file.
+ */
+export function readStoreFile(file, { raw = false } = {}) {
+  let text;
+  try {
+    text = readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  const records = parseStore(text);
+  return raw ? records : records.map(asRead);
+}
+
+/**
+ * The store names a project's records may be under: its path as given, and with its links resolved, since
+ * either may be the one its sessions ran in.
+ *
+ * @param {string} dir - The project.
+ * @returns {string[]}
+ */
+export function storeNamesOf(dir) {
+  const names = new Set([slugFor(dir)]);
+  try {
+    names.add(slugFor(realpathSync(dir)));
+  } catch {
+    // A directory that cannot be resolved is looked up as given.
+  }
+  return [...names];
+}
+
+/**
+ * A project's records.
+ *
+ * @param {string} dir - The project.
+ * @param {string} [store] - The store directory.
+ * @returns {object[]|null} Null when the store has nothing for it.
+ */
+export function projectRecords(dir, store = snapshotsDir()) {
+  for (const name of storeNamesOf(dir)) {
+    const file = join(store, `${name}.jsonl`);
+    if (existsSync(file)) return readStoreFile(file);
+  }
+  return null;
+}
+
+/**
+ * The store names a `--project` value picks, one rule for every report. A directory is that project, by the
+ * name its sessions ran under; anything else is a store name, exactly, or else every name that contains it.
+ * `stats --project ../thing` read the directory as a piece of a name, found none, and said to run a snapshot.
+ *
+ * @param {string} value - What was given.
+ * @param {string} [store] - The store directory.
+ * @returns {string[]}
+ */
+export function namesFor(value, store = snapshotsDir()) {
+  const names = (() => {
+    try {
+      return readdirSync(store).filter((f) => f.endsWith('.jsonl')).map((f) => f.slice(0, -'.jsonl'.length));
+    } catch {
+      return [];
+    }
+  })();
+  let isDir = false;
+  try {
+    isDir = statSync(resolve(value)).isDirectory();
+  } catch {
+    // Not a directory here: a name.
+  }
+  if (isDir) return storeNamesOf(resolve(value)).filter((n) => names.includes(n));
+  if (names.includes(value)) return [value];
+  return names.filter((n) => n.includes(value));
+}
+
+/** Two digits. */
+const two = (n) => String(n).padStart(2, '0');
+
+/**
+ * The day a moment fell on where this machine is, as `YYYY-MM-DD`. The store keeps UTC; the reports read
+ * the owner's day. Cut from the UTC string, `--since` and the days a report printed moved a round from the
+ * evening it ran in to the next morning for anyone west of Greenwich — 20 of one project's 130.
+ *
+ * @param {unknown} ts - An ISO timestamp.
+ * @returns {string} The day, or the first ten characters of whatever could not be read as a moment.
+ */
+export function localDay(ts) {
+  const d = new Date(String(ts ?? ''));
+  return Number.isNaN(d.getTime()) ? String(ts ?? '').slice(0, 10) : `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;
+}
+
+/**
+ * A moment where this machine is, as `YYYY-MM-DD HH:MM`.
+ *
+ * @param {unknown} ts - An ISO timestamp.
+ * @returns {string}
+ */
+export function localMinute(ts) {
+  const d = new Date(String(ts ?? ''));
+  return Number.isNaN(d.getTime()) ? String(ts ?? '') : `${localDay(ts)} ${two(d.getHours())}:${two(d.getMinutes())}`;
+}
+
+/** The zone the reports read days in, named where a report prints a time. */
+export const zone = () => Intl.DateTimeFormat().resolvedOptions().timeZone ?? 'local time';

package/src/transcripts.mjs

@@ -20,8 +20,15 @@ import { homedir } from 'node:os';
 /** Root under which Claude Code stores one directory of transcripts per project. */
 export const PROJECTS_ROOT = join(homedir(), '.claude', 'projects');
 
-/** The transcript directory of a project, by its snapshot name; `NINA_TRANSCRIPTS` moves the root, for tests. */
-export const transcriptsOf = (slug) => join(process.env.NINA_TRANSCRIPTS ?? PROJECTS_ROOT, slug);
+/**
+ * Where the transcripts are read from: Claude Code's own directory, or `NINA_TRANSCRIPTS`, which moves it for
+ * a test. Every reader asks this: listing the projects read Claude Code's own whatever the variable said, so a
+ * snapshot meant to stay in a sandbox captured the machine's real projects into it.
+ */
+const transcriptsRoot = () => process.env.NINA_TRANSCRIPTS ?? PROJECTS_ROOT;
+
+/** The transcript directory of a project, by its snapshot name. */
+export const transcriptsOf = (slug) => join(transcriptsRoot(), slug);
 
 /**
  * The verdict tokens the agent specs mandate on a report's first line, per role.
@@ -310,7 +317,7 @@ const handsBack = (row) =>
  * @param {object|null} row - A parsed transcript row.
  * @returns {boolean}
  */
-const saidToAgent = (row) => {
+export const saidToAgent = (row) => {
   if (row?.type !== 'user') return false;
   const content = row.message?.content;
   if (Array.isArray(content) && content.some((b) => b?.type === 'tool_result')) return false;
@@ -486,6 +493,9 @@ export async function scanProject(projectDir, prior = {}) {
             model: block?.input?.model ?? row?.message?.model ?? null,
             branch: row.gitBranch ?? null,
             session: row.sessionId ?? null,
+            // The Claude Code that ran the dispatch: a change in how its transcripts are written first shows
+            // as a parser that stops finding something, and this says which version it stopped at.
+            claude_code: row.version ?? null,
             verdict: null,
             verdict_source: null,
             issues: null,
@@ -757,6 +767,7 @@ async function attachAgentDetail(projectDir, dispatches) {
               model: run.model,
               branch: round.branch ?? run.branch,
               session: run.session,
+              claude_code: run.claude_code ?? null,
               verdict: null,
               verdict_source: null,
               issues: null,
@@ -884,10 +895,10 @@ export function tokensOf(usage) {
  * @returns {Promise<{slug: string, dir: string, mtime: number}[]>} The projects found.
  */
 export async function listProjects() {
-  const slugs = await readdir(PROJECTS_ROOT).catch(() => []);
+  const slugs = await readdir(transcriptsRoot()).catch(() => []);
   const out = [];
   for (const slug of slugs) {
-    const dir = join(PROJECTS_ROOT, slug);
+    const dir = transcriptsOf(slug);
     const info = await stat(dir).catch(() => null);
     if (info?.isDirectory()) out.push({ slug, dir, mtime: info.mtimeMs });
   }

package/src/wiring.mjs

@@ -125,7 +125,7 @@ export const HOOKS = [
       },
     }),
   },
-  { event: 'UserPromptSubmit', script: GATE, timeout: 10, why: "the owner's reply never starts a loop's count over" },
+  { event: 'UserPromptSubmit', script: GATE, timeout: 10, why: "the owner's reply never gives an open loop its round more" },
   {
     event: 'PreToolUse', matcher: 'Agent|Task|SendMessage', script: GATE, timeout: 10, why: 'the caps in .claude/graph.md stay instructions nothing holds',
     crash: (cannot) => ({ systemMessage: `NINA: the loop gate could not start, so the caps in .claude/graph.md are not held — ${cannot}` }),