bareloop 0.45.0 → 0.46.1

package/src/userrun.js

@@ -82,6 +82,7 @@ import { keysForDoor } from './keysfile.js';
 import { parseJsonl } from './replayio.js';
 import { claimRun, monthlyRefusalText, legSpend, chainSpend } from './monthly.js';
 import { ConfigError } from './config.js';
+import { learnAtRunEnd, hintsForRun, releaseRun } from './learnstore.js';
 import { commandFor } from './invoke.js';
 import { judgeRatesFor, keyNameFor, keyValueOf, priceReadout, ratesFor, ratesOfLine, resolveWorker, judgeRowFor, rowsForHome, REFUSE_NAME_MODEL } from './providerrows.js';
 // the banner's wall arithmetic, extracted so it is reachable by a test (F83): the
@@ -1306,6 +1307,11 @@ async function execute(ctx) {
     if (RULING.decision !== 'rerun') {
       out(`\n${RULING.decision === 'accept' ? 'ACCEPTED' : 'PAUSED'} — the verdict this run minted (${doorRecord.outcome}) is UNTOUCHED; what you answered is what happens to the work.`);
       if (RULING.decision === 'accept') {
+        // Cross-run learnings: the human Accept is what releases a held rubric run's lessons so they count (forward only; a rerun or a
+        // pause never does). Its own try/catch: a record, never a verdict.
+        if (cfgOn && DOOR !== null) {
+          try { releaseRun({ home: cfgHome, runid: DOOR.includes('/') || DOOR.endsWith('.jsonl') ? basename(DOOR).replace(/^u-/, '').replace(/\.jsonl$/, '') : DOOR }); } catch (/** @type {any} */ e) { err(`WARNING: could not release this run's lessons in the learnings ledger (${redactSecrets(String(e?.message ?? e)).split('\n')[0]}).`); }
+        }
         out(`  proved   ${ans.mechanical?.ran ?? 0} mechanical stage(s) re-ran on the tree as it stands, and passed — an accept is not a rubber stamp`);
         out(`  credit   ${ans.released ? 'RELEASED — this workflow is now eligible for reuse' : ((ctx.registry ?? null) === null ? 'not released: no --registry was named, so there is no entry to release (the answer is on the spine)' : (quarantinesCredit(spec.verdictType) ? 'nothing left to release — this row was already released by an earlier accept (a repeat answer records nothing new)' : 'nothing was held to release — a green-class row is minted born RELEASED (hamr, 2026-08-30): a machine proved it, so there was never a credit to quarantine'))}`);
         if (ans.note) out(`  note     ${ans.note}`);
@@ -1895,10 +1901,18 @@ async function execute(ctx) {
   // honours it, and the `finally` below clears whatever is left when the leg ends.
   const stopFile = stopFilePath(spineFile);
   try { rmSync(stopFile, { force: true }); } catch { /* best-effort — a stop surface must never kill the run */ }
+  // Cross-run learnings (src/learn.js): the PLANNER's block, made once from the ledger as it stood — empty when the one setting
+  // (`learningHints` in config.json) is off. A record read, never a verdict: a failure here is no hints, never a failed run.
+  /** @type {{text: string, ids: string[]}|null} */
+  let learnHints = null;
+  if (cfgOn) {
+    try { learnHints = hintsForRun({ home: cfgHome, spec, specHash }); } catch { learnHints = null; }
+  }
   let outcome;
   try {
     outcome = await runJob(spec, {
       stopFile,
+      ...(learnHints === null ? {} : { learnHints }),
       // PRD item 27/M3 — the SAME `emit` the pre-run close-timing reading above
       // used (never a second `makeSpine(spineFile)` here: two independent
       // emitters against one file would both start their seq counter at 0 and
@@ -2010,6 +2024,20 @@ async function execute(ctx) {
       appendRunEvent({ runid, type: 'settled', by: runid, spentUsd: fin.usd, spendComplete: fin.complete, at: new Date().toISOString(), ...(LEG > 1 ? { leg: LEG } : {}) }, { home: cfgHome });
     } catch (/** @type {any} */ e) { err(`WARNING: could not settle this run's claim in ~/.config/bareloop/runs.jsonl (${e.message}) — the next run settles it once this process is gone.`); }
   }
+  // The run-end tally of cross-run learnings ($0, code only, no model): the whole spine (all legs) and the gate audit become cards
+  // folded into the ONE ledger (a rubric job's are held until the human Accept). Its own try/catch, like the settle above: a
+  // record, never a verdict — a failure prints one WARNING line and can never change the outcome, the exit code or the spend.
+  // `execute` is shared by the panel, the CLI and the bundle runner, so this is the ONE call site. It runs with the hints setting
+  // on or off (OFF only means the planner is handed nothing). With no config home (a test with an injected env) it writes nothing.
+  if (je && cfgOn) {
+    try {
+      const filedAudit = ctx.bundle ? join(spineDir, 'gate-audit.jsonl') : join(spineDir, `u-${runid}-gate-audit.jsonl`);
+      learnAtRunEnd({
+        home: cfgHome, runid, events: allEvents, auditFiles: [filedAudit, join(wd, 'gate-audit.jsonl')], spec, specHash, workdir: wd,
+        trust: quarantinesCredit(spec.verdictType) ? 'rubric' : 'deterministic',
+      });
+    } catch (/** @type {any} */ e) { err(`WARNING: could not record this run's lessons in the learnings ledger (${redactSecrets(String(e?.message ?? e)).split('\n')[0]}) — the run itself is unaffected.`); }
+  }
   // the ONE spelling of the text-side scan (src/validate.js) — a hand-rolled copy
   // here would be the ninth, and one that misses a shape leaks on the very output
   // it guards. Only the COUNT is ever read out; the matches themselves stay here.

package/src/validate.js

@@ -167,14 +167,19 @@ export function closeScriptCandidateToken(cmd) {
 // redactor passes is a leak on the very output the validator was guarding.
 export const SECRET_PATTERNS = [
   /(?<![A-Za-z0-9_-])sk-[A-Za-z0-9_-]{16,}/,
-  /(?<![A-Za-z0-9_-])ghp_[A-Za-z0-9]{20,}/,
-  /(?<![A-Za-z0-9_-])github_pat_[A-Za-z0-9_]{20,}/,
-  /(?<![A-Za-z0-9_-])AKIA[0-9A-Z]{16}/,
-  /(?<![A-Za-z0-9_-])xox[bap]-[A-Za-z0-9-]{10,}/,
+  // The prefixes below are distinctive (an ordinary hyphenated word never starts with `ghp_`, `AKIA`, ...), so their left bound
+  // drops only the `-`: a key right after a hyphen (`step-ghp_...`) is still a key. `sk-` keeps the full bound above, because
+  // `sk-` ends real words (`task-`, `desk-`, `risk-`...). KNOWN LIMIT: an `sk-` key directly after a hyphen or word character
+  // (`step-sk-...`) is not found by THIS inventory, so the scan (validator, source door, pagefetch) misses it. (Measured: the
+  // redactor still masks it today, but through bareguard's own built-in `sk-` shape, not through this list.)
+  /(?<![A-Za-z0-9_])ghp_[A-Za-z0-9]{20,}/,
+  /(?<![A-Za-z0-9_])github_pat_[A-Za-z0-9_]{20,}/,
+  /(?<![A-Za-z0-9_])AKIA[0-9A-Z]{16}/,
+  /(?<![A-Za-z0-9_])xox[bap]-[A-Za-z0-9-]{10,}/,
   // Google/Gemini API key: `AIza` + 35 chars of [0-9A-Za-z_-] (39 total, fixed
   // length by Google's own issuance format). Admitted with the gemini-api
   // provider (PRD item 31.3, F160) — was missing on this branch until then.
-  /(?<![A-Za-z0-9_-])AIza[0-9A-Za-z_-]{35}/,
+  /(?<![A-Za-z0-9_])AIza[0-9A-Za-z_-]{35}/,
 ];
 const SECRET_RE = new RegExp(SECRET_PATTERNS.map((r) => r.source).join('|'));
 

package/src/worktree.js

@@ -101,7 +101,8 @@ const COMMIT_CONFIG = [
 ];
 
 /** what never goes into the work commit: the arbiter's own books and installed packages */
-const NOT_WORK = [':(exclude).smoke', ':(exclude).litectx', ':(exclude)gate-audit.jsonl', ':(exclude,glob)**/node_modules/**'];
+const NOT_WORK_PATHS = ['.smoke', '.litectx', 'gate-audit.jsonl'];
+const NOT_WORK_GLOB = ':(exclude,glob)**/node_modules/**';
 
 /**
  * The run's final commit, on whatever branch the worktree stands on: everything the run changed except the
@@ -113,7 +114,12 @@ const NOT_WORK = [':(exclude).smoke', ':(exclude).litectx', ':(exclude)gate-audi
  */
 export function commitWork(dir, message) {
   const run = (/** @type {string[]} */ args) => execFileSync('git', ['-C', dir, ...COMMIT_CONFIG, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  run(['add', '-A', '--', '.', ...NOT_WORK]);
+  // `git add` exits 1 when an exclude names a path that exists AND is gitignored (it prints "paths are ignored").
+  // An ignored path is never staged without -f, so its exclude is redundant: only exclude what git would otherwise add.
+  // check-ignore: 0 = ignored, 1 = not ignored, anything else = a real failure (execFileSync throws on 128).
+  const ignored = (/** @type {string} */ p) => { try { run(['check-ignore', '-q', '--', p]); return true; } catch (e) { if (/** @type {any} */ (e)?.status === 1) return false; throw e; } };
+  const excludes = NOT_WORK_PATHS.filter((p) => !ignored(p)).map((p) => `:(exclude)${p}`);
+  run(['add', '-A', '--', '.', ...excludes, NOT_WORK_GLOB]);
   const staged = run(['diff', '--cached', '--name-only']).trim();
   if (staged !== '') run(['commit', '-q', '-m', message]);
   return { committed: staged !== '', sha: run(['rev-parse', '--short', 'HEAD']).trim() };

package/types/attemptdiff.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cut `text` to at most `max` bytes at a LINE boundary (never mid-line).
+ * @param {string} text @param {number} max
+ * @returns {{text: string, truncated: boolean, cutLines: number}}
+ */
+export function cutAtLine(text: string, max: number): {
+    text: string;
+    truncated: boolean;
+    cutLines: number;
+};
+/**
+ * Begin recording one worker try. Call BEFORE the worker's turn; call `finish()` after
+ * (in a `finally`). Never throws.
+ * @param {{workdir: string, fence: string[], redact?: (s: string) => string}} o
+ *   `fence` = the ABSOLUTE write-scope prefixes the gate enforces for this try.
+ * @returns {Promise<{finish: () => Promise<null | {files: {path: string, diff: string, truncated: boolean, cutLines: number}[], binary: string[], truncated: boolean, gitError?: string}>}>}
+ *   `finish()` resolves null when the try changed nothing in scope.
+ */
+export function startAttemptDiff({ workdir, fence, redact }: {
+    workdir: string;
+    fence: string[];
+    redact?: (s: string) => string;
+}): Promise<{
+    finish: () => Promise<null | {
+        files: {
+            path: string;
+            diff: string;
+            truncated: boolean;
+            cutLines: number;
+        }[];
+        binary: string[];
+        truncated: boolean;
+        gitError?: string;
+    }>;
+}>;
+/** per-file and per-event byte caps for the recorded diff text */
+export const ATTEMPT_DIFF_FILE_MAX: 4096;
+export const ATTEMPT_DIFF_EVENT_MAX: 16384;

package/types/authorreadout.d.ts

@@ -303,6 +303,13 @@ export function redsRecord(reds: PlainRed[], { cases, signing }?: {
 }): Record<string, any>[];
 /** the stops this module explains in plain words */
 export const PLAIN_PROPOSAL_STOPS: readonly string[];
+/**
+ * ONE owner of the plain sentence for every drafting stop code (hamr 2026-10-09: "a user should get a reason they can
+ * understand and do something about"). What happened; `STOP_TODO` below overrides the default "draft again" where that is wrong.
+ * Used by `draftStopText` for every stop the panel and the CLI show; a code not listed reads `STOP_UNKNOWN`, never the raw code.
+ * @type {Record<string, string>}
+ */
+export const STOP_HEADS: Record<string, string>;
 /** codes the declaration gates (validateJob, validateCloseDecl) raise: one plain sentence covers the family */
 export const DECLARATION_CODES: readonly string[];
 export type PlainRed = {

package/types/config.d.ts

@@ -36,7 +36,7 @@ export function modelsProblem(list: unknown): string | null;
  * `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

package/types/inputlook.d.ts

@@ -185,29 +185,6 @@ export function labelListsOf(texts: Record<string, string>): {
     scans: Record<string, import("./labelscan.js").LabelScan>;
     lists: Record<string, string>;
 };
-/**
- * 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: string, max: number): string;
-/**
- * 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: LookNotFound[], jobLines: {
-    n: number;
-    text?: string;
-    rule?: string;
-    rules?: string[];
-}[]): {
-    line: number;
-    question: string;
-}[];
 /** the name of the answer tool - the one place the AI's report enters */
 export const LOOK_REPORT_TOOL: "report_look";
 /** how many hits one search returns at most, and how long a snippet or a read line is */

package/types/labelscan.d.ts

@@ -29,6 +29,12 @@ export const MIN_COUNT: 1;
 export const MAX_PER_SHAPE: 40;
 /** only this much of a source is scanned (a source over it is scanned up to a line end) */
 export const SCAN_MAX_CHARS: 2000000;
+/**
+ * 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: RegExp;
 export type LabelEntry = {
     id: string;
     label: string;