bareloop 0.37.0 → 0.39.0

package/src/calibrate.js

@@ -61,10 +61,10 @@
 import { createHash } from 'node:crypto';
 import {
   LOCATE_LABEL, LOCATE_AXES, CALIBRATION_SIZE,
-  runLocate, decide, expectedOf, validateCard, validateCalibrationSet,
+  runLocate, decide, expectedOf, validateCard, validateCalibrationSet, docQuoteInBlock,
 } from './judged.js';
 import { JUDGE_ATTEMPTS } from './kinds.js';
-import { tallyCalls } from './text.js';
+import { tallyCalls, scrubRaw } from './text.js';
 import { PROVIDER_TIMEOUT_MS } from './clock.js';
 
 /** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
@@ -280,20 +280,87 @@ export function factsResist(facts, gold, artifactText) {
   if (gotNames.join(',') !== wantNames.join(',')) {
     return { ok: false, why: `the located function list moved: expected ${wantNames.join(', ')}, got ${gotNames.join(', ') || '(none)'}` };
   }
-  const lines = new Set(artifactText.split('\n').map((l) => l.trim()).filter(Boolean));
   for (const w of want) {
     const f = got.find((/** @type {any} */ x) => String(x?.name ?? '') === w.name);
     const q = typeof f?.docQuote === 'string' && f.docQuote.trim() !== '' ? f.docQuote : null;
     if (!w.hasDoc && q !== null) {
       return { ok: false, why: `${w.name} has no JSDoc block and the extraction reported one` };
     }
-    if (w.hasDoc && (q === null || !q.includes('/**') || !lines.has(q.trim()))) {
+    // ONE OWNER of "this quote points at the real doc block" (docQuoteInBlock, the same call
+    // `has-doc`'s decide() makes). The judge routinely quotes a worded line inside the block
+    // rather than the `/**` opener, and since ruling A (0f27db5) that is a good pointer; the
+    // declaration it names must be this function's own, so a block above another one still leaks.
+    const decl = typeof f?.declarationQuote === 'string' ? f.declarationQuote : null;
+    if (w.hasDoc && (q === null || decl === null || !decl.includes(w.name) || !docQuoteInBlock(artifactText, decl, q))) {
       return { ok: false, why: `${w.name} IS documented and the extraction did not report its real JSDoc opener` };
     }
   }
   return { ok: true, why: null };
 }
 
+// ── THE DIAGNOSTIC RECORD (F192) ────────────────────────────────────────────
+//
+// A refusal must be diagnosable from its OWN record. `expectedOf` drops `why` and
+// `quote` on purpose (a signer cannot predict the judge's wording, so grading must
+// not pin it), and the judge's raw locate facts used to be written nowhere — so a
+// `has-doc` red could not be told apart as "no docQuote", "not a /** opener" or
+// "a quoted line is not in the artifact". `diag` is a NEW field beside the graded
+// ones: nothing here is read by grading, the compare, the hashes or any verdict.
+// Every string passes through `scrubRaw` — the ONE secret inventory plus the one
+// announced bound — so a quote that carries a key is masked and a long one says
+// how much was withheld rather than silently clipping.
+
+/** the per-string cap on anything the diagnostic keeps (bytes, scrubbed) */
+export const DIAG_STRING_CAP = 400;
+/** the most elements of one array the diagnostic keeps before it says it stopped */
+const DIAG_ARRAY_CAP = 32;
+
+/** @param {unknown} v @returns {string} */
+const diagText = (v) => scrubRaw({ label: 'diag', attempt: 0, text: v, cap: DIAG_STRING_CAP }).text;
+
+/**
+ * A facts tree, deep-copied with every string scrubbed and bounded. Depth is
+ * bounded too: facts are a shallow list of functions, and anything deeper is not
+ * a shape this pipe reads.
+ * @param {any} v @param {number} [depth] @returns {any}
+ */
+function diagFacts(v, depth = 0) {
+  if (typeof v === 'string') return diagText(v);
+  if (v === null || typeof v !== 'object') return v;
+  if (depth >= 4) return diagText(JSON.stringify(v));
+  if (Array.isArray(v)) {
+    const kept = v.slice(0, DIAG_ARRAY_CAP).map((x) => diagFacts(x, depth + 1));
+    if (v.length > DIAG_ARRAY_CAP) kept.push(`[${v.length - DIAG_ARRAY_CAP} more element(s) withheld — the cap is ${DIAG_ARRAY_CAP} per array]`);
+    return kept;
+  }
+  return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, diagFacts(x, depth + 1)]));
+}
+
+/**
+ * What one graded artifact's record KEEPS about how it was judged: every locate
+ * attempt's axis and cause, the judge's facts as returned, and the decision's
+ * full reds per rule.
+ * @param {{diagTries: any[], facts: any, decision: any}} r
+ */
+function diagOf({ diagTries, facts, decision }) {
+  /** @type {{rule: string, fn: string, why: string, quote: string|null}[]} */
+  const reds = [];
+  for (const item of decision?.items ?? []) {
+    for (const x of item?.reds ?? []) {
+      reds.push({
+        rule: String(item?.rule ?? ''), fn: String(x?.fn ?? ''), why: diagText(x?.why),
+        quote: typeof x?.quote === 'string' ? diagText(x.quote) : null,
+      });
+    }
+  }
+  return {
+    attempts: diagTries,
+    facts: facts === null || facts === undefined ? null : diagFacts(facts),
+    reds,
+    reason: typeof decision?.reason === 'string' ? diagText(decision.reason) : null,
+  };
+}
+
 // ── THE GATE ────────────────────────────────────────────────────────────────
 
 /**
@@ -320,6 +387,10 @@ async function pipeOnce({ artifactText, card, judgeLoop, judgeModel, attempts, m
   let last = null;
   /** @type {any[]} */
   const tries = [];
+  /** the diagnostic twin of `tries` (F192): the same attempts, with the cause text
+   * `tries` never carried. A separate array so `casualty.attempts` is unchanged.
+   * @type {any[]} */
+  const diagTries = [];
   // TIGHTEN-ONLY, FLOOR 1 — the same clamp shape every bound in this pipeline
   // carries. A caller may buy fewer retries than the ladder allows and never
   // more; ZERO is not a cheaper gate, it is a gate that grades nothing and has
@@ -327,7 +398,7 @@ async function pipeOnce({ artifactText, card, judgeLoop, judgeModel, attempts, m
   const bound = Math.max(1, Math.min(Math.trunc(Number(attempts)) || 0, JUDGE_ATTEMPTS));
   for (let attempt = 1; attempt <= bound; attempt += 1) {
     const halt = capStop();
-    if (halt) return { ok: false, budget: halt, tries, red: null, facts: null, decision: null };
+    if (halt) return { ok: false, budget: halt, tries, diagTries, red: null, facts: null, decision: null };
     last = await runLocate({
       artifactText,
       card,
@@ -348,11 +419,12 @@ async function pipeOnce({ artifactText, card, judgeLoop, judgeModel, attempts, m
       }),
     });
     tries.push({ attempt, ok: last.ok, axis: last.red?.axis ?? null, costUsd: last.costUsd });
+    diagTries.push({ attempt, ok: last.ok, axis: last.red?.axis ?? null, detail: last.red ? diagText(last.red.detail) : null });
     if (last.ok) break;
     if (last.red.axis === LOCATE_AXES.PRICING) break;
   }
-  if (!last.ok) return { ok: false, budget: null, tries, red: last.red, facts: null, decision: null };
-  return { ok: true, budget: null, tries, red: null, facts: last.facts, decision: decide(last.facts, card, { artifactText }) };
+  if (!last.ok) return { ok: false, budget: null, tries, diagTries, red: last.red, facts: null, decision: null };
+  return { ok: true, budget: null, tries, diagTries, red: null, facts: last.facts, decision: decide(last.facts, card, { artifactText }) };
 }
 
 /**
@@ -393,7 +465,7 @@ async function pipeOnce({ artifactText, card, judgeLoop, judgeModel, attempts, m
  *   onCost?: (c: any) => void, attempts?: number, battery?: any[], batteryCard?: any,
  *   capStop?: () => 'cap-halt'|'pricing-red'|null}} o
  * @returns {Promise<{ok: boolean, stop: string|null, casualty: any,
- *   graded: {id: string, ok: boolean, got: any, want: any, detail: string|null}[],
+ *   graded: {id: string, ok: boolean, got: any, want: any, detail: string|null, diag: any}[],
  *   injection: {styles: any[], allResisted: boolean, leaks: string[]},
  *   failures: string[], reds: Red[], judgeModel: string,
  *   cardHash: string|null, casesHash: string|null, setHash: string|null,
@@ -517,7 +589,7 @@ export async function runCalibration({
         ...stamped,
         stop: r.red.axis,
         graded,
-        casualty: { at: String(c.id), kind: 'case', axis: r.red.axis, detail: r.red.detail, attempts: r.tries },
+        casualty: { at: String(c.id), kind: 'case', axis: r.red.axis, detail: r.red.detail, attempts: r.tries, diag: diagOf(r) },
         reds: [{
           code: r.red.axis,
           path: `calibration.cases.${c.id}`,
@@ -535,6 +607,7 @@ export async function runCalibration({
       got,
       want: { verdict: c.expect.verdict, reds: (c.expect.reds ?? []).map((/** @type {any} */ x) => ({ rule: x.rule, fn: x.fn })) },
       attempts: r.tries,
+      diag: diagOf(r),
       detail: cmp.ok ? null : [
         cmp.verdictOk ? null : `verdict: signed "${c.expect.verdict}", the pipe rendered "${got.verdict}"`,
         cmp.missing.length ? `expected red(s) the pipe did not raise: ${cmp.missing.join('; ')}` : null,
@@ -562,7 +635,7 @@ export async function runCalibration({
         stop: r.red.axis,
         graded,
         injection: { styles, allResisted: false, leaks: [] },
-        casualty: { at: b.id, kind: 'injection', axis: r.red.axis, detail: r.red.detail, attempts: r.tries },
+        casualty: { at: b.id, kind: 'injection', axis: r.red.axis, detail: r.red.detail, attempts: r.tries, diag: diagOf(r) },
         reds: [{
           code: r.red.axis,
           path: `injection.${b.id}`,
@@ -581,6 +654,7 @@ export async function runCalibration({
       resisted: facts.ok && cmp.ok,
       factsOk: facts.ok,
       decisionOk: cmp.ok,
+      diag: diagOf(r),
       got,
       want: { verdict: b.expect.verdict, reds: b.expect.reds.map((/** @type {any} */ x) => ({ rule: x.rule, fn: x.fn })) },
       detail: facts.ok && cmp.ok ? null : (facts.why ?? `the decision moved: ${[

package/src/cardauthor.js

@@ -228,7 +228,7 @@ export const COMPILE_SYSTEM = 'You compile a person\'s own words into a rubric a
 export function cardCasesPrompt({ answers, questions = {} }) {
   const qKey = SOFTGREEN_JUDGE_EXAMPLES_KEY;
   const q = questions[qKey] ?? JUDGE_EXAMPLES_QUESTION;
-  const rules = JUDGE_RULE_IDS.map((id) => `- ${id}\n    the facts it reads: ${JUDGE_RULES[id].ask.trim().split('\n')[0].trim()}`);
+  const rules = JUDGE_RULE_IDS.map((id) => `- ${id}\n    what it can check: ${JUDGE_RULES[id].means}\n    the facts it reads: ${JUDGE_RULES[id].ask.trim().split('\n')[0].trim()}`);
 
   return `You are compiling ONE person's answers into the two artifacts a judged close is signed with.
 
@@ -266,6 +266,9 @@ at — plus what the arbiter must decide about it.
 
 AT LEAST ONE PASS AND AT LEAST ONE RED. A set that can only fail one way measures nothing.
 Every rule you name in a case must be a rule your card carries.
+A case may expect a red only where the rule's "what it can check" line says it can raise one on that artifact: a
+function with any doc block above it never breaks has-doc, and "the doc only restates the function name" is a
+says-what red, never a has-doc one.
 
 HOW TO ANSWER
 

package/src/declaredclose.js

@@ -272,13 +272,13 @@ export function declaredStages(closeDecl) {
  *
  * @param {any} closeDecl
  * @param {{at?: string, listing?: string[]|null, deferListing?: boolean,
- *   catalogue?: Record<string, any>, verdictType?: string|null}} [opts]
+ *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null}} [opts]
  * @returns {{ok: boolean, reds: Red[], closeDecl: any, grounded: boolean,
  *   scoped: {scoped: boolean, via: string|null},
  *   ceiling: {class: string, kind: string, stage: string|null, locked: boolean}|null}}
  */
 export function validateCloseDecl(closeDecl, opts = {}) {
-  const { at = 'closeDecl', listing = null, catalogue, verdictType = null } = opts;
+  const { at = 'closeDecl', listing = null, catalogue, verdictType = null, writeScope = null } = opts;
   const deferListing = opts.deferListing === true;
   /** @type {Red[]} */
   const reds = [];
@@ -401,6 +401,7 @@ export function validateCloseDecl(closeDecl, opts = {}) {
     ...(deferListing ? { deferListing: true } : {}),
     guards: classGuards({ verdictType: picked, lang: closeDecl.lang }),
     verdictType: picked,
+    writeScope,
     envOwned: owned,
     // POST-injection: an owned name is accepted only when its value is EXACTLY
     // the recorded one. `{}` (nothing recorded) keeps the pre-injection rule, so
@@ -678,14 +679,19 @@ export async function runDeclaredStages(stages, redact = (s) => s, opts = {}) {
  *    recommend a top-up on a dying run — the one direction trend.js names as
  *    dangerous. F6's answer applies: unknown, never a number that means the
  *    opposite of what it says.
- *  - a stage with no measurement at all donates nothing, for the same reason.
+ *  - a JUDGED stage (no measurement) donates its distinct red COUNT, always 'down';
+ *  - any other stage with no measurement at all donates nothing, for the same reason.
  * The stage POSITION still travels either way, so "the run got further than it
  * ever had" is readable on every declared close.
  * @param {any} stage @param {any} r the M1 StageResult
  * @returns {number|null}
  */
 function trendValueOf(stage, r) {
-  if (typeof r?.value !== 'number' || !Number.isFinite(r.value)) return null;
+  if (typeof r?.value !== 'number' || !Number.isFinite(r.value)) {
+    // a JUDGED stage has no measurement: its number is how many DISTINCT reds it itemizes
+    // (F192 e), lower-is-better, compared to its best-so-far like any deterministic count
+    return Number.isInteger(r?.detail?.redCount) ? r.detail.redCount : null;
+  }
   return stage?.params?.direction === 'lower-is-better' ? r.value : null;
 }
 

package/src/job.js

@@ -757,7 +757,7 @@ function validatePlanShape(spec, red, reds) {
     // class the user picked (PRD v1.57 §2), so the gate cannot check D5 without
     // it. An unknown or locked class is refused there, on its own axis, beside
     // the counted `request-red` above.
-    const cd = validateCloseDecl(spec.closeDecl, { at: 'closeDecl', deferListing: true, verdictType: spec.verdictType });
+    const cd = validateCloseDecl(spec.closeDecl, { at: 'closeDecl', deferListing: true, verdictType: spec.verdictType, writeScope: spec.writeScope });
     for (const r of cd.reds) reds.push(r);
     if (demanded !== undefined && !CLASS_BY_CLOSE.declared.includes(demanded)) {
       // the same laundering guard as the close-type hierarchy, one level up: a