bareloop 0.40.0 → 0.42.0

package/src/source.js

@@ -23,14 +23,16 @@
 // on rather than catch.
 
 import { createHash } from 'node:crypto';
+import { tmpdir } from 'node:os';
 import { existsSync, lstatSync, readFileSync } from 'node:fs';
-import { mkdir, readdir, readFile, writeFile, lstat, stat, chmod, access, copyFile, cp, open, rm, realpath, readlink, symlink, constants as fsConstants } from 'node:fs/promises';
+import { mkdir, mkdtemp, readdir, readFile, writeFile, lstat, stat, chmod, access, copyFile, cp, open, rm, realpath, readlink, symlink, constants as fsConstants } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep, basename, isAbsolute } from 'node:path';
 import { git } from './kinds.js';
 import { addWorktree, hideBareloopDir } from './worktree.js';
 import { MAX_BUFFER } from './kinds.js';
 import { PROVIDER_TIMEOUT_MS } from './clock.js';
 import { scanSecrets, SECRET_PATTERNS, SECRET_PATTERN_NAMES } from './validate.js';
+import { fetchPageText, isWebUrl } from './pagefetch.js';
 
 /** @typedef {{stop: string, code: string}} SourceRefusal a named, non-throwing stop */
 
@@ -1223,3 +1225,166 @@ export async function proveInputFiles(inputs) {
   }
   return { ok: true, repo, root };
 }
+
+/** the per-file ceiling for a rubric input: bareguard's `cited` check searches a quote in a source only up to this size
+ * (its `quoteSourceMaxBytes`); a bigger file could never be cited from, so the door refuses it at $0 */
+export const RUBRIC_INPUT_MAX_BYTES = 5 * 1024 * 1024;
+
+/**
+ * Does this source manifest belong to a rubric job on local files (`proveRubricInputs` wrote it)? One spelling for both
+ * doors (the panel session and the CLI author run): a non-repo source that froze numbered, labelled input files.
+ * @param {Record<string, any>|null|undefined} manifest
+ * @returns {boolean}
+ */
+export function isRubricFilesManifest(manifest) {
+  return !!manifest && manifest.kind !== 'repo' && Array.isArray(manifest.inputs) && manifest.inputs.length > 0;
+}
+
+/**
+ * PART 1a (docs/product/ITEM33-BUILD.md, "Addendum 2026-10-12"): the front door for a RUBRIC job whose inputs are the
+ * person's own LOCAL FILES, not a repo. Each numbered `label: /absolute/file` line is proven at $0 and frozen into the
+ * same hidden-git tree a plain folder gets (`prepareSource`, which also refuses a secret shape, an environment file
+ * and a symlink), under `input/`; the manifest then also records `inputs: [{label, rel, sha256}]` — the bytes the
+ * rubric's `cited` check will search a quote in, hashed once, here. A line that is a web address is fetched ONCE with
+ * barebrowse (PART 1c, read only) and its text frozen under `input/` like a file (the manifest row also records its `url`,
+ * so run start can fetch it again); a `search:` line is a named refusal (a later build); so is a relative path, a missing file, a folder, a file over
+ * {@link RUBRIC_INPUT_MAX_BYTES}, and text that is not valid UTF-8. Every refusal is plain words naming the line and
+ * ends "Nothing spent." — nothing here touches a model.
+ * @param {{inputs: {n: number, label: string, value: string}[], into: string, destination?: string, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>}} o `fetchUrl` - how a web address is read (default barebrowse via `fetchPageText`; a test injects a stub, never the network)
+ * @returns {Promise<{ok: true, prep: {stop: null, into: string, tree: string, manifestPath: string, manifest: Record<string, any>}}|{ok: false, error: string, code: string}>}
+ */
+export async function proveRubricInputs({ inputs, into, destination, fetchUrl = (u) => fetchPageText(u) }) {
+  /** @param {string} code @param {number} n @param {string} msg @returns {{ok: false, error: string, code: string}} */
+  const bad = (code, n, msg) => ({ ok: false, code, error: `line ${n}: ${msg} Nothing spent.` });
+  if (!Array.isArray(inputs) || inputs.length === 0) return { ok: false, code: 'inputs-missing', error: 'Inputs is required. Nothing spent.' };
+  /** @type {Set<string>} */
+  const labels = new Set();
+  /** @type {{label: string, name: string, buf: Buffer, url?: string}[]} */
+  const staged = [];
+  /** @type {Set<string>} */
+  const names = new Set();
+  const utf8 = new TextDecoder('utf-8', { fatal: true });
+  for (const inp of inputs) {
+    const { n, label, value } = inp;
+    if (/^search$/i.test(label) || (/^[a-z][a-z0-9+.-]*:\/\//i.test(value) && !isWebUrl(value))) {
+      return bad('web-input', n, 'a search, or an address that is not http or https, is not an input yet.');
+    }
+    if (labels.has(label.toLowerCase())) return bad('label-repeat', n, `the label "${label}" is already used by an earlier line.`);
+    labels.add(label.toLowerCase());
+    if (isWebUrl(value)) {
+      const got = await fetchUrl(value.trim());
+      if (!got.ok) return bad('input-url-unreadable', n, `${got.error.replace(/[.\s]+$/, '')}.`);
+      const pageBuf = Buffer.from(got.text, 'utf8');
+      const leak = secretPatternNames(got.text);
+      if (leak.length) return bad('input-url-secret', n, `the page at ${got.url} carries a known secret shape (${leak.join(', ')}) - refused, secrets never enter a job.`);
+      const stem = label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'page';
+      const pageName = names.has(`${stem}.txt`) ? `${n}-${stem}.txt` : `${stem}.txt`;
+      names.add(pageName);
+      staged.push({ label, name: pageName, buf: pageBuf, url: got.url });
+      continue;
+    }
+    if (!isAbsolute(value)) return bad('input-not-absolute', n, `${value} must be the full path of a file, like /home/me/notes.md.`);
+    const abs = resolve(value);
+    let ls;
+    try { ls = await lstat(abs); } catch { return bad('input-missing', n, `${abs} does not exist.`); }
+    if (ls.isSymbolicLink()) return bad('input-symlink', n, `${abs} is a symlink — refused, never followed.`);
+    if (!ls.isFile()) return bad('input-not-file', n, `${abs} is not a file — each input line is one file.`);
+    const base = basename(abs);
+    if (ENV_FILE.test(base)) return bad('input-env-file', n, `${abs} is an environment file — refused by name, whatever it contains.`);
+    if (ls.size > RUBRIC_INPUT_MAX_BYTES) return bad('input-oversize', n, `${abs} is over the ${RUBRIC_INPUT_MAX_BYTES / (1024 * 1024)} MiB limit for a quoted input.`);
+    const buf = await readFile(abs);
+    try { utf8.decode(buf); } catch { return bad('input-not-utf8', n, `${abs} is not UTF-8 text — text files only for now.`); }
+    if (hasNulByte(buf)) return bad('input-not-text', n, `${abs} is not a text file — text files only for now.`);
+    // two files with one name keep the line number in front, so neither overwrites the other under input/
+    const name = names.has(base) ? `${n}-${base}` : base;
+    names.add(name);
+    staged.push({ label, name, buf });
+  }
+  const stage = await mkdtemp(join(tmpdir(), 'bareloop-rubric-inputs-'));
+  try {
+    for (const f of staged) await writeFile(join(stage, f.name), f.buf);
+    const prep = await prepareSource({ source: stage, into, ...(destination === undefined ? {} : { destination }) });
+    if (prep.stop !== null) return { ok: false, code: prep.code, error: prep.stop };
+    // `source` names the person's own first file, never the scratch staging folder that was already removed
+    const manifest = {
+      ...prep.manifest,
+      source: isWebUrl(inputs[0].value) ? inputs[0].value.trim() : resolve(inputs[0].value),
+      inputs: staged.map((f) => ({ label: f.label, rel: `input/${f.name}`, sha256: sha256Hex(f.buf), ...(f.url === undefined ? {} : { url: f.url }) })),
+    };
+    await writeFile(prep.manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return { ok: true, prep: { ...prep, manifest } };
+  } finally {
+    await rm(stage, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Is this Inputs value a path to an existing regular FILE on this machine (not a repo folder, not a web address, not a
+ * missing path)? The $0 peek that tells a rubric job on local files from a rubric job on a repo before a session exists;
+ * `proveRubricInputs` makes the authoritative, line-by-line proof.
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function looksLikeLocalFile(value) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value) || !isAbsolute(value)) return false;
+  try { return lstatSync(resolve(value)).isFile(); } catch { return false; }
+}
+
+/**
+ * Is this Inputs value one a rubric job can work on without a repo: a regular FILE on this machine, or a web address (PART 1c)?
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function looksLikeRubricInput(value) {
+  return isWebUrl(value) || looksLikeLocalFile(value);
+}
+
+/**
+ * RUN START for a rubric job with web inputs (PART 1c, RF22): fetch every web input AGAIN and make that text the run's frozen input
+ * BEFORE the worker starts. The drafting copy was only for the look (prices change); the close grades, and the worker reads, THIS
+ * copy. It is written into the prepared tree, committed as the new seed (so the page is never read as a worker write), and
+ * `source.json` is rewritten (new sha256 per input, new seed, `draftSha256` keeps what the look saw). Nothing but the text of a
+ * recorded web address is ever refetched; a job with only file inputs returns at once and changes nothing.
+ * @param {{into: string, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>}} o `into` - the prepared copy (source.json + tree/)
+ * @returns {Promise<{ok: true, refreshed: string[], seed: string|null}|{ok: false, error: string}>}
+ */
+export async function refreezeUrlInputs({ into, fetchUrl = (u) => fetchPageText(u) }) {
+  const read = await readSourceManifest(into);
+  if (read.stop !== null) return { ok: false, error: read.stop };
+  if (!read.present || !read.manifest) return { ok: true, refreshed: [], seed: null };
+  const manifest = read.manifest;
+  const rows = Array.isArray(manifest.inputs) ? manifest.inputs.filter((/** @type {any} */ r) => r && typeof r.url === 'string' && r.url !== '') : [];
+  if (rows.length === 0) return { ok: true, refreshed: [], seed: null };
+  const tree = join(resolve(into), 'tree');
+  /** @type {{row: any, buf: Buffer}[]} */
+  const fresh = [];
+  for (const row of rows) {
+    const got = await fetchUrl(row.url);
+    if (!got.ok) return { ok: false, error: `Input "${row.label}": ${got.error}. The run did not start. Nothing spent.` };
+    const leak = secretPatternNames(got.text);
+    if (leak.length) return { ok: false, error: `Input "${row.label}": the page at ${got.url} carries a known secret shape (${leak.join(', ')}) - refused, secrets never enter a job. The run did not start. Nothing spent.` };
+    fresh.push({ row, buf: Buffer.from(got.text, 'utf8') });
+  }
+  for (const f of fresh) await writeFile(join(tree, f.row.rel), f.buf);
+  const add = await git(tree, [...NO_HOOKS, 'add', '-A', '-f']);
+  if (!add.ok) return { ok: false, error: `the fresh page copy could not be staged: ${add.err}. The run did not start. Nothing spent.` };
+  const commit = await git(tree, [...GIT_IDENTITY, ...NO_HOOKS, 'commit', '-q', '--allow-empty', '-m', 'bareloop: run start - fresh copy of the web inputs']);
+  if (!commit.ok) return { ok: false, error: `the fresh page copy could not be committed: ${commit.err}. The run did not start. Nothing spent.` };
+  const head = await git(tree, ['rev-parse', 'HEAD']);
+  if (!head.ok) return { ok: false, error: `git rev-parse HEAD failed in ${tree}: ${head.err}. The run did not start. Nothing spent.` };
+  const seed = head.out.trim();
+  const byLabel = new Map(fresh.map((f) => [f.row.label, f.buf]));
+  const inputs = manifest.inputs.map((/** @type {any} */ r) => {
+    const buf = byLabel.get(r.label);
+    return buf === undefined || typeof r.url !== 'string' ? r : { ...r, draftSha256: r.draftSha256 ?? r.sha256, sha256: sha256Hex(buf) };
+  });
+  const files = Array.isArray(manifest.files) ? manifest.files.map((/** @type {any} */ m) => {
+    const hit = inputs.find((/** @type {any} */ r) => typeof r.url === 'string' && r.rel === `input/${m.path}`);
+    if (!hit) return m;
+    const buf = byLabel.get(hit.label);
+    return buf === undefined ? m : { ...m, bytes: buf.length, sha256: sha256Hex(buf) };
+  }) : manifest.files;
+  const next = { ...manifest, inputs, files, seed, refrozenAt: new Date().toISOString() };
+  await writeFile(join(resolve(into), 'source.json'), `${JSON.stringify(next, null, 2)}\n`);
+  return { ok: true, refreshed: rows.map((/** @type {any} */ r) => r.label), seed };
+}

package/src/thinking.js

@@ -0,0 +1,130 @@
+// rewritten-from: fwdloop src/thinking.js@f9449e8
+// PANEL-BUILD.md P8 batch 5 — THE one owner of what a drafting or judging model call sends for thinking. bareloop keeps NO per-model
+// thinking list and NO vendor regex: bare-agent (>=0.52) owns which request shape switches thinking for which model, and
+// `thinkingSupport(kind, model, {baseUrl})` is its own pure lookup (no network): `true` (measured switchable), `false` (measured
+// NOT switchable), `'unverified'` (not measured — the shape ladder is tried at runtime; if every shape fails with a client
+// validation error ONE plain request decides, and the call still runs, reported `thinkingStatus: 'unsupported'`).
+//
+// The tick is the person's, per job ("Thinking on", the signed optional `thinking` field; absent = off). It covers DRAFTING and the
+// rubric JUDGE; the WORKER is never handed a thinking option. PER-CALL options, never constructor options (the drafter's provider is
+// the worker's instance, deliberately left as it was). The raw `thinking` option is never sent (bare-agent throws if both are set).
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { thinkingSupport: baseSupport, AnthropicProvider, OpenAIProvider, GeminiProvider } = require('bare-agent/providers');
+
+/** The words under a greyed "Thinking on" box (the server's `thinking.canChange` decides; the page decides nothing). */
+export const THINKING_FIXED_SAY = "can't change this for this model";
+
+/** API shape id -> bare-agent's thinking-ladder kind. A missing shape (clipipe, a test double) has no kind. */
+const KIND_OF_SHAPE = Object.freeze({ 'anthropic-api': 'anthropic', 'openai-api': 'openai', 'gemini-api': 'gemini' });
+
+/**
+ * What bare-agent knows about switching this model's thinking. A missing kind, a non-function `impl`, or a throw all read
+ * `'unverified'` — never a guess in either direction.
+ * @param {string} shape an API shape id (src/providershapes.js)
+ * @param {string} model
+ * @param {{ baseUrl?: string|null, impl?: Function }} [o] `impl` is a test seam; production uses bare-agent's own
+ * @returns {true|false|'unverified'}
+ */
+export function thinkingSupport(shape, model, { baseUrl, impl = baseSupport } = {}) {
+  const kind = /** @type {Record<string, string>} */ (KIND_OF_SHAPE)[shape];
+  if (kind === undefined || typeof impl !== 'function') return 'unverified';
+  try {
+    const r = impl(kind, model, baseUrl ? { baseUrl } : undefined);
+    return r?.switchable === true ? true : (r?.switchable === false ? false : 'unverified');
+  } catch { return 'unverified'; }
+}
+
+/**
+ * The per-call options for one support answer and one tick (`true` = "Thinking on"). The table (PANEL-BUILD.md P8, ruling Q1):
+ *   tick on : true -> on | false -> {} (the box is greyed, cannot be on) | 'unverified' -> on
+ *   tick off: true -> off | false -> {} (the model thinks as it would) | 'unverified' -> off (bare-agent decides; plain request on failure)
+ * @param {true|false|'unverified'} support
+ * @param {boolean} tick
+ * @returns {{ thinkingMode: 'on'|'off' } | {}}
+ */
+export function thinkingOptions(support, tick) {
+  if (support === false) return {};
+  return { thinkingMode: tick ? 'on' : 'off' };
+}
+
+/** The enumerated operator knob a drafting call is built with: 'on' | 'off' (the tick, spelled as a word). */
+export const THINKING_MODES = Object.freeze(['on', 'off']);
+
+/**
+ * Throw unless `mode` is one of {@link THINKING_MODES} — an operator-param guard, so a typo never silently means a mode.
+ * @param {unknown} mode
+ * @returns {'on'|'off'}
+ */
+export function assertThinkingMode(mode) {
+  if (mode === 'on' || mode === 'off') return mode;
+  throw new Error(`[thinking] draftThinking must be one of ${THINKING_MODES.join(' | ')}, got ${JSON.stringify(mode)}`);
+}
+
+/**
+ * The API shape of a constructed bare-agent provider (the three client classes only); `null` for a test double or a clipipe.
+ * @param {any} provider
+ * @returns {string|null}
+ */
+export function shapeOfProvider(provider) {
+  if (provider instanceof AnthropicProvider) return 'anthropic-api';
+  if (provider instanceof OpenAIProvider) return 'openai-api';
+  if (provider instanceof GeminiProvider) return 'gemini-api';
+  return null;
+}
+
+/**
+ * The per-call options every DRAFTING and JUDGING model call on this provider instance carries for this mode. A provider that is
+ * not one of the three client classes (a test double, a clipipe) is never sent the switch.
+ * @param {any} provider a constructed bare-agent provider
+ * @param {unknown} [mode] 'on' | 'off' (default 'off')
+ * @returns {{ thinkingMode: 'on'|'off' } | {}}
+ */
+export function thinkingCallOptions(provider, mode = 'off') {
+  const m = assertThinkingMode(mode);
+  const shape = shapeOfProvider(provider);
+  if (shape === null) return {};
+  return thinkingOptions(thinkingSupport(shape, String(provider.model), { baseUrl: provider.baseUrl }), m === 'on');
+}
+
+/**
+ * What the drafting calls will carry for a model the caller has only NAMED (shape, model id, Base URL) — no key, no network. The
+ * first drafting row is shown from this, before the key is read.
+ * @param {{providerName: string, model: string, baseUrl?: string|null}} o
+ * @param {unknown} [mode] 'on' | 'off'
+ * @returns {{ support: true|false|'unverified', mode: 'on'|'off', options: {thinkingMode?: 'on'|'off'} }}
+ */
+export function thinkingPlanFor({ providerName, model, baseUrl }, mode = 'off') {
+  const m = assertThinkingMode(mode);
+  const support = thinkingSupport(providerName, model, { baseUrl });
+  return { support, mode: m, options: thinkingOptions(support, m === 'on') };
+}
+
+/**
+ * The server's answer for one Model-menu line: whether the "Thinking on" box can change and the words under it. `false` greys and
+ * unticks the box (the note reads {@link THINKING_FIXED_SAY}); `'unverified'` leaves it enabled with no note.
+ * @param {string} shape @param {string} model @param {string|null|undefined} baseUrl
+ * @returns {{ support: true|false|'unverified', canChange: boolean, say: string }}
+ */
+export function thinkingForLine(shape, model, baseUrl) {
+  const support = thinkingSupport(shape, model, { baseUrl });
+  return { support, canChange: support !== false, say: support === false ? THINKING_FIXED_SAY : '' };
+}
+
+/**
+ * The first drafting row's words — code-owned, ALWAYS starting "thinking on" or "thinking off". `status` is bare-agent's own
+ * `thinkingStatus` for a call that has run ('applied' | 'unsupported' | 'ignored' | 'unknown'); undefined = before any call, read from
+ * the plan (`support`, `mode`).
+ * @param {{ mode: 'on'|'off', support?: true|false|'unverified', status?: string }} s
+ * @returns {string}
+ */
+export function thinkingRowText({ mode, support, status }) {
+  if (status === 'applied') return `thinking ${mode}`;
+  if (status === 'unsupported') return "thinking on (this model can't change it)";
+  if (status === 'ignored') return 'thinking on (the model thought anyway)';
+  if (status === 'unknown') return `thinking ${mode} (not confirmed)`;
+  if (support === false) return "thinking on (this model can't change it)";
+  if (support === 'unverified') return `thinking ${mode} (not verified for this model)`;
+  return `thinking ${mode}`;
+}

package/src/u-readout.js

@@ -202,7 +202,7 @@ export function reviewDoorPackage({ door, diff }) {
   const out = [];
   out.push(`REVIEW DOOR — this run's close minted ${String(d.outcome ?? 'a verdict')} and it STANDS. Nothing you do here changes it.`);
   if (held) {
-    out.push('  held     this green was rendered by the judged floor, so it has earned NO reuse and NO learning credit until you accept it');
+    out.push('  held     this is a rubric (soft-green) job, so its green earns NO reuse and NO learning credit until you accept it, whether or not a judge ran');
   }
   // the body: what the machine judged, what moved, and the lines themselves —
   // rendered by the SAME code the pause screen uses, off the same record shape.