bareloop 0.44.0 → 0.46.0

package/src/config.js

@@ -9,6 +9,7 @@
 //
 // Shape (unknown fields are kept, never dropped):
 //   { "monthlyLimitUsd": <number > 0>,          // absent = no limit, no check
+//     "learningHints": true|false,               // absent = false: the planner is handed cross-run learnings (src/learn.js); the tally is kept either way
 //     "keys":   { "<ENV NAME>": { "shape": "<shape id>", "baseUrl": "http(s)://…", "legacyMaxTokens": true|false } },
 //     "models": { "<ENV NAME>": [ { "model": "<id>", "use": true|false, "inPerM": n, "outPerM": n } ] } }
 // An older file's `keys.<ENV>.{name,priceInPerM,priceOutPerM}` is tolerated and read as ONE model
@@ -91,7 +92,7 @@ export function providerFieldProblem(field, v) {
 }
 
 /** A Base URL as stored: trailing slashes dropped. @param {string} v @returns {string} */
-export const cleanBaseUrl = (v) => v.replace(/\/+$/, '');
+export const cleanBaseUrl = (v) => v.replace(/(?<!\/)\/+$/, '');
 
 /**
  * THE one rule for a row's model lines, used by config validation and the Settings routes. A price
@@ -128,6 +129,7 @@ export function modelsProblem(list) {
  */
 function docProblem(doc) {
   // monthlyLimitUsd is NOT judged here: `monthlyLimitOf` (src/monthly.js) owns its read-time sentence
+  if (doc.learningHints !== undefined && typeof doc.learningHints !== 'boolean') return 'learningHints must be true or false';
   if (doc.keys !== undefined) {
     if (doc.keys === null || typeof doc.keys !== 'object' || Array.isArray(doc.keys)) return 'keys must be an object of key variable names';
     for (const [env, row] of Object.entries(doc.keys)) {
@@ -156,7 +158,7 @@ function docProblem(doc) {
  * `keys` merges per key variable name, then per field; `models.<ENV>` is REPLACED WHOLE (`null`
  * clears it). Validated before anything is written; nothing is written on a refusal.
  *
- * Patch fields understood: `monthlyLimitUsd` (finite > 0), `keys.<ENV>.{shape,baseUrl,legacyMaxTokens}`,
+ * Patch fields understood: `monthlyLimitUsd` (finite > 0), `learningHints` (true | false), `keys.<ENV>.{shape,baseUrl,legacyMaxTokens}`,
  * `models.<ENV>` (a list judged by {@link modelsProblem}). The first write of a row's `models` list
  * removes that row's older `name` / `priceInPerM` / `priceOutPerM` in the SAME write (never two
  * sources); a retired top-level `anthropicBalanceNote` is dropped on any write. Any other field is
@@ -176,6 +178,7 @@ export function updateConfig(patch, opts = {}) {
     if (k === 'monthlyLimitUsd' && !(typeof v === 'number' && Number.isFinite(v) && v > 0)) {
       throw new ConfigError('monthlyLimitUsd must be a number above 0 (remove the limit to have none)');
     }
+    if (k === 'learningHints' && typeof v !== 'boolean') throw new ConfigError('learningHints must be true or false');
     next[k] = v;
   }
   delete next.anthropicBalanceNote;

package/src/fitcheck.js

@@ -0,0 +1,166 @@
+// THE FIT CHECK (docs/product/ITEM33-BUILD.md "Addendum 2026-10-21 - fit check build spec", F243, fit POC v6). A rubric job, at drafting, once, after the
+// inputs are frozen and before the look: ONE paid AI call splits each job line into the short parts it asks for (words copied from that line) and says,
+// for each, whether the saved page shows it, with a quote copied from the page. The AI never decides: plain code checks every ask against its own
+// line and every quote against the page, and a part not found becomes one question to the person (never a stop by itself, never a count). Failure is
+// OPEN - a wrong stop is the costly mistake - so a call that does not finish is `absent` and drafting goes on. The call/book/retry pattern is
+// src/pagemap.js's `runPageMap`.
+
+import { createRequire } from 'node:module';
+import { priceOf, scrubRaw, tallyCalls, capStop, callCasualty } from './text.js';
+import { redactSecrets } from './validate.js';
+import { isTransportFailure } from './transport.js';
+import { isRateLimited, rateLimitWaitMs } from './ratelimit.js';
+import { isOutputCutOff } from './authorflow.js';
+import { AUTHOR_CALL_TIMEOUT_MS, AUTHOR_SCOUT_MAX_TOKENS, SURVEY_CAUSES } from './authorscout.js';
+
+const require = createRequire(import.meta.url);
+const { Loop } = require('bare-agent');
+
+/** the label of the one paid call, as the drafting book and the progress line see it */
+export const FIT_CALL_LABEL = 'fit-check';
+/** what the chat says when the check did not finish (drafting goes on) */
+export const FIT_ABSENT_NOTE = 'The fit check did not finish; drafting goes on.';
+/** the answer that keeps drafting after the fit question (any case, a closing full stop allowed) */
+export const FIT_GO_ON = 'go on';
+/** @param {unknown} text @returns {boolean} */
+export const isGoOn = (text) => norm(String(text ?? '').trim().replace(/\.$/, '')) === FIT_GO_ON;
+
+export const FIT_SYSTEM = 'You check whether saved web pages show what a job asks for. You never invent words: every ask must be copied from its job line and every quote must be copied from the page, character for character.';
+
+/** collapse whitespace, lower case: the one spelling every fit comparison uses @param {unknown} s @returns {string} */
+export const norm = (s) => String(s).replace(/\s+/g, ' ').trim().toLowerCase();
+
+/**
+ * What the AI is told: the job lines (the numbered text only, no `~` rules) and the WHOLE text of every input under its label. Adapted from the POC
+ * call (.claude/scratch/fit-poc6/run.mjs): the asks are copied from each job line instead of hand-written.
+ * @param {{jobLines: {n: number, text: string}[], texts: Record<string, string>}} o
+ * @returns {string}
+ */
+export function fitPrompt({ jobLines, texts }) {
+  const job = jobLines.map((l) => `LINE ${l.n}: ${l.text}`).join('\n');
+  const pages = Object.entries(texts).map(([label, text]) => `THE PAGE (the input "${label}"):\n${text}`).join('\n\n');
+  return `THE JOB:\n${job}\n\n${pages}\n\n`
+    + 'For EACH job line, split it into the short parts it asks for (for example where it starts, where it ends, a price, a time), using ONLY words copied from that line. '
+    + 'Every line has at least one part. For EACH part, say whether the page shows it the way the job means it. A page that shows the opposite (for example a flight that arrives where the job says it leaves from, or a different city) does NOT show it. '
+    + 'If found, copy a short piece of page text that shows it, character for character. If not found, quote is null. '
+    + 'Reply with JSON only, no prose, no code fence: {"asks":[{"line":<line number>,"ask":"<the part, copied from that line>","found":true|false,"quote":"<page text or null>"}]}';
+}
+
+/** @typedef {{line: number, ask: string, found: boolean, quote: string|null, madeUp: boolean, ignored?: 'number'}} FitAsk */
+
+/** an ask that is only a number (a count the job gives, not something the page shows): digits, optional spaces, commas, dots @param {string} ask @returns {boolean} */
+const isNumberOnly = (ask) => /^\d[\d\s,.]*$/.test(norm(ask));
+
+/**
+ * Read the AI's reply and decide, all in code. Malformed (no repair): not JSON, another form, a line that is not a job line, an ask not copied from its own
+ * line, found not a boolean, a quote neither text nor null, or a job line with no ask. An ask is found only if `found` is true AND its quote is on a page;
+ * `found` with a quote that is not on any page (or no quote) is made up and counts as not found.
+ * @param {unknown} text the reply
+ * @param {{n: number, text: string}[]} jobLines
+ * @param {Record<string, string>} texts the frozen input texts by label
+ * @returns {{status: 'malformed'}|{status: 'ok', state: 'fits'|'ask', asks: FitAsk[], notFound: {line: number, ask: string}[]}}
+ */
+export function decideFit(text, jobLines, texts) {
+  /** @type {any} */
+  let j;
+  try { j = JSON.parse(String(text ?? '').trim()); } catch { return { status: 'malformed' }; }
+  if (j === null || typeof j !== 'object' || Array.isArray(j) || !Array.isArray(j.asks)) return { status: 'malformed' };
+  const lines = new Map(jobLines.map((l) => [l.n, norm(l.text)]));
+  const pages = Object.values(texts).map(norm);
+  /** @type {FitAsk[]} */
+  const asks = [];
+  for (const a of j.asks) {
+    if (a === null || typeof a !== 'object' || Array.isArray(a)) return { status: 'malformed' };
+    if (!Number.isInteger(a.line) || !lines.has(a.line)) return { status: 'malformed' };
+    if (typeof a.ask !== 'string' || norm(a.ask) === '' || !(/** @type {string} */ (lines.get(a.line))).includes(norm(a.ask))) return { status: 'malformed' };
+    if (typeof a.found !== 'boolean') return { status: 'malformed' };
+    const quote = a.quote ?? null;
+    if (quote !== null && typeof quote !== 'string') return { status: 'malformed' };
+    const q = quote === null ? '' : norm(quote);
+    const onPage = q !== '' && pages.some((p) => p.includes(q));
+    // a bare number is ignored: kept in the record (flagged), never counted, never asked about
+    asks.push({ line: a.line, ask: a.ask, found: a.found && onPage, quote, madeUp: a.found && !onPage, ...(isNumberOnly(a.ask) ? { ignored: /** @type {'number'} */ ('number') } : {}) });
+  }
+  if (!jobLines.every((l) => asks.some((a) => a.line === l.n))) return { status: 'malformed' };
+  const notFound = asks.filter((a) => !a.ignored && !a.found).map((a) => ({ line: a.line, ask: a.ask }));
+  return { status: 'ok', state: notFound.length === 0 ? 'fits' : 'ask', asks, notFound };
+}
+
+/** the not-found asks as the person reads them: `<ask> (line N), <ask> (line N)` @param {{line: number, ask: string}[]} notFound @returns {string} */
+export const notFoundList = (notFound) => notFound.map((x) => `${x.ask} (line ${x.line})`).join(', ');
+
+/**
+ * The one question, worded by code.
+ * @param {{found: number, total: number, notFound: {line: number, ask: string}[]}} o
+ * @returns {string}
+ */
+export const fitQuestionText = ({ found, total, notFound }) => redactSecrets(
+  `I found ${found} of ${total} of your asks on this page. Not found: ${notFoundList(notFound)}. Type go on to keep drafting, or anything else to stop and change the job or the page.`,
+);
+
+/** the default loop seam - one spelling of how this repo drives a model */
+const defaultLoop = (/** @type {any} */ { system, onLlmResult, provider, rates }) =>
+  new Loop({ provider, system, onLlmResult, ...(rates ? { rates } : {}) });
+
+/**
+ * Run the fit check: one call (one retry on a malformed reply or a transport failure or a 429). Never throws on a call casualty; every failure is `absent`.
+ * @param {{jobLines: {n: number, text: string}[], texts: Record<string, string>, provider?: any, maxTokens?: number, ceilingUsd?: number|null,
+ *   callTimeoutMs?: number, onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string, raw?: string}) => void,
+ *   createLoop?: Function, rates?: {in: number, out: number}|null, callOptions?: Record<string, any>, sleep?: (ms: number) => Promise<void>}} o
+ * @returns {Promise<{state: 'fits'|'ask'|'absent', asks: FitAsk[], notFound: {line: number, ask: string}[], reason: string|null, cause: string|null,
+ *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[], budgetStop: 'cap-halt'|'pricing-red'|null}>}
+ */
+export async function runFitCheck({
+  jobLines, texts, provider = null, maxTokens = AUTHOR_SCOUT_MAX_TOKENS, ceilingUsd = null, callTimeoutMs = AUTHOR_CALL_TIMEOUT_MS,
+  onCall = () => {}, createLoop = defaultLoop, rates = null, callOptions = {}, sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+}) {
+  const callTimeout = Number.isFinite(Number(callTimeoutMs)) && Number(callTimeoutMs) > 0
+    ? Math.min(Math.trunc(Number(callTimeoutMs)), AUTHOR_CALL_TIMEOUT_MS) : AUTHOR_CALL_TIMEOUT_MS;
+  const priced = rates ? { rates } : {};
+  /** @type {{label: string, costUsd: number|null, unpricedRounds: number}[]} */
+  const calls = [];
+  let attempts = 0;
+  const record = (/** @type {any} */ r) => {
+    const call = { label: FIT_CALL_LABEL, ...priceOf(r) };
+    calls.push(call);
+    const raw = scrubRaw({ label: FIT_CALL_LABEL, attempt: attempts, text: r?.text });
+    onCall({ ...call, raw: raw.text, ...(r?.thinkingStatus === undefined ? {} : { thinkingStatus: r.thinkingStatus }) });
+  };
+  const absent = (/** @type {string} */ reason, /** @type {string} */ cause, /** @type {'cap-halt'|'pricing-red'|null} */ budgetStop = null) => ({
+    state: /** @type {'absent'} */ ('absent'), asks: [], notFound: [], reason, cause, calls, budgetStop,
+  });
+  const content = fitPrompt({ jobLines, texts });
+  let malformed = 0;
+  let transportRetried = false;
+  let rateRetried = false;
+  for (;;) {
+    // the cap is checked BEFORE every call, never inside one
+    const halt = capStop({ ceilingUsd, ...tallyCalls(calls) });
+    if (halt) return absent(halt === 'cap-halt' ? `the fit check was not made: the $${ceilingUsd} ceiling was already spent` : 'the fit check was not made: spend could not be priced, so the ceiling could not be enforced', SURVEY_CAUSES.NOT_FUNDED, halt);
+    attempts += 1;
+    const loop = createLoop({ system: FIT_SYSTEM, onLlmResult: undefined, provider, ...priced });
+    /** @type {any} */
+    let r;
+    try {
+      r = await loop.run([{ role: 'user', content }], [], { cacheMessages: true, maxTokens, timeoutMs: callTimeout, ...callOptions });
+    } catch (e) {
+      if (isRateLimited(e) && !rateRetried) {
+        const wait = rateLimitWaitMs(e);
+        if (wait !== null) { rateRetried = true; await sleep(wait); continue; }
+      }
+      const casualty = callCasualty(e) ?? (isTransportFailure(e) ? String(/** @type {any} */ (e)?.message ?? e) : null);
+      if (casualty === null) throw e;
+      // the failed attempt may already be billed: booked UNPRICED, so the spend stays "not complete" (never a $0)
+      record({ error: casualty });
+      if (!transportRetried) { transportRetried = true; continue; }
+      return absent(`the fit check call failed: ${redactSecrets(casualty)}`, SURVEY_CAUSES.CALL_FAILED);
+    }
+    record(r);
+    if (isOutputCutOff(r)) return absent('the fit check answer was cut off', SURVEY_CAUSES.UNPARSEABLE);
+    if (r?.error) return absent(`the fit check call failed: ${redactSecrets(String(r.error))}`, SURVEY_CAUSES.CALL_FAILED);
+    const d = decideFit(r?.text, jobLines, texts);
+    if (d.status === 'ok') return { state: d.state, asks: d.asks, notFound: d.notFound, reason: null, cause: null, calls, budgetStop: null };
+    malformed += 1;
+    if (malformed >= 2) return absent('the fit check answer was not readable twice', SURVEY_CAUSES.UNPARSEABLE);
+  }
+}

package/src/inputlook.js

@@ -8,9 +8,8 @@
 // not on the list is NOT carried into the report - it is moved to "could not check", named. Code never decides two words mean the
 // same: the AI proposes, the list and the source prove.
 
-import { scanLabels, labelOnList, renderLabelList, normLabel, LABEL_SHAPES } from './labelscan.js';
+import { scanLabels, labelOnList, renderLabelList, normLabel, LABEL_SHAPES, TAG } from './labelscan.js';
 import { FACT_SHAPES, FACT_OPS } from './facts.js';
-import { lineRules } from './rubricstep.js';
 import { dropRows, dropLine } from './pagedropwords.js';
 
 /** the name of the answer tool - the one place the AI's report enters */
@@ -20,7 +19,6 @@ export const LOOK_MAX_HITS = 40;
 const SNIPPET = 220;
 const READ_LINE = 320;
 const READ_LINES = 40;
-const TAG = /\[[A-Za-z]+=[^\]\s]*\]/g;
 const WS = /[\s   ]+/g;
 
 /**
@@ -290,47 +288,3 @@ export function labelListsOf(texts) {
 }
 
 export { LABEL_SHAPES };
-
-/**
- * L3: a reason the AI gave, cut only at a sentence end (never mid-sentence): whole sentences while they fit in `max` characters,
- * and nothing at all if the first one alone does not fit. A trailing full stop is dropped (the caller closes the clause).
- * @param {string} text @param {number} max @returns {string}
- */
-export function wholeSentences(text, max) {
-  const sentences = text.replace(/\s+/g, ' ').trim().split(/(?<=[.!?])\s+/).filter(Boolean);
-  let out = '';
-  for (const s of sentences) {
-    const next = out === '' ? s : `${out} ${s}`;
-    if (next.length > max) break;
-    out = next;
-  }
-  return out.replace(/[.!?]+$/, '');
-}
-
-/**
- * I1 (hamr, 2026-10-13, "Ruled by hamr" 2): when the look shows the person's intent on one `~` rule was NOT captured - its words or
- * meaning are not in the source - the person is asked about THAT rule at once, named by its line and rule. Only a look entry that names
- * a rule number counts; anything else the look could not find is not asked piecemeal (it is Not checked, or the whole job is reviewed).
- * The wording is the code's own, never the model's. The keep-or-drop and the cap are `normalizeQuestions` (src/authorflow.js).
- * @param {LookNotFound[]} notFound @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
- * @returns {{line: number, question: string}[]} every candidate question (the caller applies the machine's caps)
- */
-export function ruleQuestions(notFound, jobLines) {
-  /** @type {{line: number, question: string}[]} */
-  const out = [];
-  /** @type {Set<string>} */
-  const seen = new Set();
-  for (const n of Array.isArray(notFound) ? notFound : []) {
-    if (!Number.isInteger(n.rule)) continue;
-    const line = jobLines.find((l) => l.n === n.line);
-    const rule = line ? lineRules(line)[/** @type {number} */ (n.rule) - 1] : undefined;
-    if (!line || rule === undefined) continue;
-    const key = `${n.line}:${n.rule}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const words = n.words ? `${JSON.stringify(n.words)} (from your words)` : 'what this rule asks for';
-    const why = wholeSentences(String(n.why), 200);
-    out.push({ line: n.line, question: `Line ${n.line}, rule ${n.rule} - "${rule}": I could not find ${words} in your input${why ? ` (${why})` : ''}. What do you mean by it? Your answer is added as a new ~ rule on line ${n.line}.` });
-  }
-  return out;
-}

package/src/judged.js

@@ -323,7 +323,7 @@ export function docQuoteInBlock(text, declQuote, docQuote) {
  */
 function hasDocBlockDirectlyAbove(text, fn) {
   const n = fn.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const re = new RegExp(`^(?:export\\s+)?(?:default\\s+)?(?:(?:async\\s+)?function\\s*\\*?\\s*${n}\\b`
+  const re = new RegExp(`^(?:export\\s+)?(?:default\\s+)?(?:(?:async\\s+)?function\\s*(?:\\*\\s*)?${n}\\b`
     + `|(?:const|let|var)\\s+${n}\\s*=|(?:static\\s+)?(?:async\\s+)?${n}\\s*\\()`);
   const hits = text.split('\n').map((l) => l.trim()).filter((l) => re.test(l));
   if (hits.length !== 1) return false;
@@ -401,7 +401,7 @@ function sharesPrefix(a, b) {
  * @param {string} text @returns {string[]}
  */
 function patternFields(text) {
-  const m = /^\s*\{([^{}[\]()]*)\}\s*(?:=\s*\{\s*\})?\s*$/.exec(text);
+  const m = /^\s*\{([^{}[\]()]*)\}(?:\s*=\s*\{\s*\})?\s*$/.exec(text);
   if (!m || m[1].includes('...')) return [];
   /** @type {string[]} */
   const out = [];
@@ -417,7 +417,7 @@ function patternFields(text) {
 /** a doc-block line with its comment decoration (opener, leading star, closer) removed
  * @param {string} line @returns {string} */
 function undecorated(line) {
-  return line.trim().replace(/^\/\*+/, '').replace(/\*+\/$/, '').replace(/^\*+/, '').trim();
+  return line.trim().replace(/^\/\*+/, '').replace(/(?<!\*)\*+\/$/, '').replace(/^\*+/, '').trim();
 }
 
 /**

package/src/labelscan.js

@@ -28,22 +28,31 @@ const MAX_GAP_LABEL = 24;
 const MIN_PHRASE = 3;
 /** how many repeated phrases are looked behind */
 const MAX_PHRASES = 20;
-/** a line is scanned up to this many characters, and for this many values (a minified page is one huge line; the bound keeps the scan linear) */
+/** a line is scanned up to this many characters, and for this many values (a minified page is one huge line; the bound caps the work per line, each finder's own regex is kept linear below) */
 const MAX_LINE = 20000;
 const MAX_VALUES_PER_LINE = 400;
 /** only this much of a source is scanned (a source over it is scanned up to a line end) */
 export const SCAN_MAX_CHARS = 2_000_000;
 
 const WS = /[\s   ]+/g;
-const TAG = /\[[A-Za-z]+=[^\]\s]*\]/g;
+/**
+ * The page reader's bracketed tag (`[ref=549]`), shared by the three places that strip it. The lookahead and lookbehind add no match and drop no
+ * match: a `[` that sits inside the run of an earlier `[letters=` (no `]` or white space between) is skipped, because that earlier start reads the same
+ * run to the same end - it matches (and consumes this one) or fails (and so does this one). Without them "[a=[a=[a=..." with no `]` is quadratic.
+ */
+export const TAG = /\[(?=[A-Za-z]+=)(?<!\[[A-Za-z]+=[^\]\s]*?)[A-Za-z]+=[^\]\s]*\]/g;
 const MONTH = '(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)';
 /** value finders in priority order: an earlier shape owns a span a later one would also match */
 const FINDERS = /** @type {[string, RegExp][]} */ ([
   ['date', new RegExp(`\\b\\d{4}-\\d{2}-\\d{2}\\b|\\b\\d{1,2}/\\d{1,2}/\\d{2,4}\\b|\\b${MONTH}\\.? \\d{1,2}(?:, \\d{4})?\\b|\\b\\d{1,2} ${MONTH}\\.? \\d{4}\\b`, 'g')],
   ['time', /\b\d{1,2}:\d{2}(?: ?[AaPp]\.?[Mm]\.?)?(?![\w:])/g],
-  ['money', /[$€£] ?\d[\d,]*(?:\.\d+)?|\b\d[\d,]*(?:\.\d+)? ?(?:US dollars?|dollars?|USD|euros?|EUR|pounds?|GBP)\b/g],
+  // the 2nd shape's leading lookbehind skips a start inside a digit/comma run that an earlier start of the run already covers (that start reads the same
+  // run to the same end, so it matches first or fails like this one); without it "1,1,1,...x" is quadratic. The covering start is never one right after
+  // a "." - the digits of a decimal can already belong to an earlier match ("$1.5,2 dollars" reads "2 dollars" as its own)
+  ['money', /[$€£] ?\d[\d,]*(?:\.\d+)?|(?<!(?<!\.)\b\d[\d,]*?)\b\d[\d,]*(?:\.\d+)? ?(?:US dollars?|dollars?|USD|euros?|EUR|pounds?|GBP)\b/g],
   ['number', /(?<![\w.,])\d[\d,]*(?:\.\d+)?(?![\w]|\.\d)/g],
-  ['text', /[A-Za-z]*\d[\w.\-]*/g],
+  // (?<![A-Za-z]): a start inside a run of letters is covered by the run's first letter (same match, earlier), so a long run of letters with no digit is linear
+  ['text', /(?<![A-Za-z])[A-Za-z]*\d[\w.\-]*/g],
 ]);
 const PHRASE = /\b[A-Z][a-z]+(?: [A-Z][a-z]+)+\b/g;
 

package/src/ladder.js

@@ -58,11 +58,11 @@ export const STRIKE_LIMIT = 2;
  */
 const VOLATILE = [
   // TAP's own timing line, dropped WHOLE: its value is the only thing on it
-  [/^[ \t]*#?[ \t]*duration_ms[ \t]*[:=].*$/gm, ''],
+  [/^[ \t]*(?:#[ \t]*)?duration_ms[ \t]*[:=].*$/gm, ''],
   // ISO-8601 stamps, wherever they appear in a close's output
   [/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, '<ts>'],
   // any millisecond figure (`(1.738ms)`, `took 12 ms`)
-  [/\d+(?:\.\d+)?[ \t]*ms\b/g, '<ms>'],
+  [/(?<!\d)\d+(?:\.\d+)?[ \t]*ms\b/g, '<ms>'],
 ];
 
 /**