bareloop 0.41.0 → 0.43.0

package/src/planrun.js

@@ -45,6 +45,7 @@ import { defaultJudgeLoop } from './judged.js';
 export { rateSourceFields };
 import { createClock, isWallTimeout } from './clock.js';
 import { isDeclaredClose, runDeclaredStages, validateCloseDecl, closeGrade, HUMAN_PAUSE, HITL_PAUSE, HITL_DECISION_RED } from './declaredclose.js';
+import { inputLabelsOf } from './rubricstep.js';
 import {
   seedAtHead, seedListing, changedSet, GAP_TRIM_MARKER, GATE_AUDIT_FILE, ARBITER_BOOK_STORES,
   HUMAN_KIND, HUMAN_DECISIONS, normalizeHumanRuling, resolveHumanRuling,
@@ -540,6 +541,10 @@ export const BOUND_REASON_MAX = 200;
 
 /** the recorded reason for a step attempt whose round was cut at the output cap (F122 2A b) */
 export const TRUNCATED_REASON = 'output cut at the token limit (max_tokens)';
+/** the red fed to the redraft when the first replan answer was cut off (plain words, from code) */
+const REPLAN_CUT_RED = 'Your previous answer was cut off at its length limit before the plan was complete. Answer again with a shorter plan that fits.';
+/** the plain sentence for a replan answer cut off at its length limit (hamr 2026-10-16, run mv9gm796) */
+export const REPLAN_CUT_WORDS = 'The replan answer was cut off at its length limit, so no new plan came back.';
 
 /**
  * What the NEXT attempt is told about the bound that cut the previous one.
@@ -1886,7 +1891,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       },
       decisionReady: true,
       decision: `The close minted ${outcome} and it STANDS. What happens to the work is yours: accept it, rerun it with your own words as the gap, or pause and come back.`
-        + (held ? ' This green was rendered by the judged floor, so it has earned no reuse until you accept it.' : ''),
+        + (held ? ' This is a rubric (soft-green) job, so its green earns no reuse until you accept it, whether or not a judge ran.' : ''),
       options: [...HUMAN_DECISIONS],
       meaning: 'not a verdict — the verdict is already minted and nothing an answer does can change it; this records a disposition',
     });
@@ -2036,7 +2041,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     }
     const listed = await seedListing(workdir, s.seedRef);
     const v = listed.stop === null
-      ? validateCloseDecl(job.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: job.verdictType, writeScope: job.writeScope, jobLines: Array.isArray(job.jobLines) ? job.jobLines : null })
+      ? validateCloseDecl(job.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: job.verdictType, writeScope: job.writeScope, jobLines: Array.isArray(job.jobLines) ? job.jobLines : null , inputLabels: inputLabelsOf(job.inputs) })
       : { ok: false, grounded: false, reds: [{ code: 'listing-unreadable', path: 'closeDecl', detail: listed.stop }] };
     emit('close-decl', {
       genre: job.closeDecl.genre,
@@ -2231,7 +2236,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    * denied, the wallet as its budget), granted tools only (the menu IS the
    * grant), per-attempt round bound via loop.stop() (F20), every round metered
    * with a phase label (F12).
-   * @param {{granted: string[], phase: string, attemptRounds: number, attempts: number|null, writable: boolean, root?: ReturnType<typeof createRoot>|null, fence?: string[]|null, workerProvider?: any}} o
+   * @param {{granted: string[], phase: string, attemptRounds: number, attempts: number|null, writable: boolean, root?: ReturnType<typeof createRoot>|null, fence?: string[]|null, workerProvider?: any, truncatedBounded?: boolean}} o
    *   `root` (Layer R): when present, the worker's write-class actions are teed
    *   for the within-run ratchet — staged before the gate decides, discarded on
    *   deny/halt, settled to landed-or-not after execution (the two axes, F43/F7).
@@ -2241,7 +2246,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    *   STRIKE LADDER (src/ladder.js), where that count does not exist by design — see
    *   the turn-allowance note below.
    */
-  async function mkWorker({ granted, phase, attemptRounds, attempts, writable, root = null, fence = null, workerProvider = null }) {
+  async function mkWorker({ granted, phase, attemptRounds, attempts, writable, root = null, fence = null, workerProvider = null, truncatedBounded = false }) {
     // THE HARD RULE, ENFORCED STRUCTURALLY (PRD v1.57 §3). This is the ONE seam
     // that grants write-class verbs — `writeScope` is empty for every other
     // worker, so a read-only phase cannot reach a file whatever it intends — and
@@ -2824,8 +2829,10 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // cut round's output is discarded (bare-agent already dropped it), its spend is booked
       // by the per-round meter, the tree is judged as it stands, and the step's strike
       // ladder (or the fix governor) applies unchanged (hamr ruling A extended it to `fix`
-      // after run muux1x96). Scout, drafter, replan keep the transport route below.
-      if (r.error && r.error.startsWith('truncated:') && (phase.startsWith('step:') || phase === 'fix')) {
+      // after run muux1x96). hamr 2026-10-16 (run mv9gm796) extended it to the REPLAN call: the
+      // replan drafter opts in with `truncatedBounded`. Scout and the first draft keep the
+      // transport route below (provider-red).
+      if (r.error && r.error.startsWith('truncated:') && (phase.startsWith('step:') || phase === 'fix' || truncatedBounded)) {
         attemptBounded = { iteration: roundIteration, cause: 'truncated', reason: TRUNCATED_REASON };
         emit('attempt-bounded', { phase, iteration: roundIteration, rounds: roundsThisAttempt, cap: attemptRounds, reason: TRUNCATED_REASON, stopReason: r.stopReason ?? null });
         return r;
@@ -3007,9 +3014,13 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
    * the hard line) — a drafter built once at full budget would let the replan
    * draft spend against money the steps had already consumed.
    * @param {string} phase @param {string|null} failure
-   * @param {string} [progress] the meter's read, replan only (A's adaptation channel) */
+   * @param {string} [progress] the meter's read, replan only (A's adaptation channel)
+   * @returns {Promise<{ok: boolean, reds: any[], plan?: any, truncated?: boolean}>} */
   const obtainPlan = async (phase, failure, progress) => {
-    const drafter = await mkWorker({ granted: [], phase: 'plan', attemptRounds: 2, attempts: 3, writable: false });
+    const drafter = await mkWorker({ granted: [], phase: 'plan', attemptRounds: 2, attempts: 3, writable: false, truncatedBounded: phase === 'replan' });
+    /** the LAST draftPlan call was a replan answer cut off at max_tokens: a bounded failed attempt,
+     * never provider-red (hamr 2026-10-16); reset at the start of every call */
+    let replanCut = false;
     // The BALANCE, read live at each draft — never a snapshot and never a rate
     // (addendum 2). At draft it is the whole budget (scale); at replan it is what
     // is actually left, which is the adaptation channel.
@@ -3038,7 +3049,12 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     };
     const draftPlan = async (/** @type {any[]|null} */ reds) => {
       drafter.setIteration(reds ? 'redraft' : 'draft');
+      replanCut = false;
       const r = await drafter.ask(planPrompt(job, scoutBlob, reds, maxStepRounds, failure, scopeMenu, materials, starting, checkFacts, doorWords?.text ?? null, readShim), []);
+      if (phase === 'replan' && typeof r.error === 'string' && r.error.startsWith('truncated:')) {
+        replanCut = true;
+        return '';
+      }
       return extractArtifact(r.text).code ?? '';
     };
     // Scrubbed HERE, once, before any consumer reads them — the judge() precedent
@@ -3055,10 +3071,17 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       return { ...v, reds: v.reds.map((r) => (typeof r.detail === 'string' ? { ...r, detail: scrub(r.detail) } : r)) };
     };
     let text = await draftPlan(null);
-    let pv = validate(text);
+    // A cut-off replan answer is treated like a BAD one: its half text is never validated (judging
+    // half an artifact would mint a plan-red the drafter never earned), it becomes one plain-words
+    // red fed to the redraft, and a cut REDRAFT (whatever the first answer was) is the bounded
+    // failed attempt the caller escalates in words.
+    let pv = replanCut
+      ? { ok: false, reds: [{ code: 'parse-error', path: '$', detail: REPLAN_CUT_RED }], plan: null }
+      : validate(text);
     emit('plan-validate', { ok: pv.ok, reds: pv.reds, phase: `${phase}-1` });
     if (!pv.ok) {
       text = await draftPlan(pv.reds);
+      if (replanCut) return { ok: false, reds: [], truncated: true };
       pv = validate(text);
       emit('plan-validate', { ok: pv.ok, reds: pv.reds, phase: `${phase}-2` });
     }
@@ -3658,6 +3681,16 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
         planExecuted();
         return relay(e, 'replan');
       }
+      if (pv.truncated) {
+        // a bounded failed attempt in plain words, filed as plan-red (a judged no, not a casualty)
+        // with the code-owned sentence on the escalation; the panel reads `cause` to say it
+        emit('escalation', {
+          category: 'plan-red', cause: 'truncated', decisionReady: true, phase: 'replan',
+          decision: REPLAN_CUT_WORDS, options: ['change the job and run it again', 'abandon the run'], detail: TRUNCATED_REASON,
+        });
+        planExecuted();
+        return 'plan-red';
+      }
       if (!pv.ok) {
         for (const r of pv.reds) emit('plan-red', r);
         planExecuted();

package/src/providerrows.js

@@ -9,7 +9,7 @@
 //
 // This module is also THE one owner of "model -> key + shape + URL": Chat's Model menu,
 // the author doors and the run doors all resolve through `findRow` / `keyNameFor` /
-// `applyConfiguredKey` / `modelChoiceFor` below — no second lookup exists. Key VALUES
+// `keyValueOf` / `modelChoiceFor` below — no second lookup exists. Key VALUES
 // never pass through here — only names.
 import { readConfig } from './config.js';
 import { filledKeyNames } from './keysfile.js';
@@ -388,8 +388,8 @@ export function judgeRowFor(rows, judge, workerProvider, workerRow) {
  * the worker's own provider it calls the worker's endpoint, so a row on that endpoint with a line
  * NAMED for the judge's model prices it ({@link ratesFor}); a judge model that is absent or names
  * no line there keeps the worker's price (the worker's row, or none = the guess). A different
- * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`applyConfiguredKey`,
- * by the worker's model), so the two can come from different rows.
+ * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`judgeRowFor`:
+ * the worker's own row when the judge shares its provider), so the two can come from different rows.
  * @param {{ provider: string, model?: string|null }} judge
  * @param {string|null|undefined} workerProvider
  * @param {string|null|undefined} workerBaseUrl

package/src/reviewdoor.js

@@ -50,6 +50,43 @@ export function doorRecordOf(events) {
   return events.findLast?.((e) => e?.type === REVIEW_DOOR) ?? null;
 }
 
+/**
+ * Was this run's door ACCEPTED, honoured? A `door-decision` record with `decision: 'accept'` and `honoured: true`
+ * (written by {@link answerReviewDoor}, whichever surface asked: the CLI, or the panel's Accept). Pure, off the
+ * run's spine. A refused accept (`honoured: false`) does not count.
+ * @param {any[]} events the run's spine, parsed
+ * @returns {boolean}
+ */
+export function doorAccepted(events) {
+  return Array.isArray(events) && events.some((e) => e?.type === 'door-decision' && e.decision === 'accept' && e.honoured === true);
+}
+
+/**
+ * T D.2 — a SCHEDULED run's green is held until the person accepts it (T10): a run that carries a `trigger.json` (a scheduled
+ * start wrote it) and holds no honoured accept. One shared predicate: `getStartFrom` reads its outcome as `'green-held'` (so
+ * the Reuse start refuses it unchanged), `listReuseJobs` skips it, and the schedule gate does not count it. A hand run is never held.
+ * @param {any[]} events the run's spine, parsed @param {any} triggerRec the run's `trigger.json`, or null
+ * @returns {boolean}
+ */
+export function heldScheduled(events, triggerRec) {
+  return !!triggerRec && typeof triggerRec === 'object' && !doorAccepted(events);
+}
+
+/**
+ * Is this run WAITING for the person's Accept? Its spine holds a door record, the door has not expired ({@link doorAgeGate}),
+ * and no honoured `accept` or `rerun` decision follows it (a `pause` keeps the same three doors open). One owner: the runs
+ * list's Needs-you `Accept` tag, the Run tab's Accept button and the scheduled NEXT line all read this.
+ * @param {any[]} events the run's spine, parsed
+ * @param {{now?: () => number}} [opts]
+ * @returns {boolean}
+ */
+export function doorWaiting(events, opts = {}) {
+  const door = doorRecordOf(events);
+  if (!door || !doorAgeGate(door, opts.now ? { now: opts.now } : {}).ok) return false;
+  const at = events.lastIndexOf(door);
+  return !events.slice(at + 1).some((e) => e?.type === 'door-decision' && e.honoured === true && (e.decision === 'accept' || e.decision === 'rerun'));
+}
+
 /**
  * IS THE DOOR STILL OPEN? The same 60-day TTL a hitl checkpoint keeps
  * (`PAUSE_TTL_MS`) and deliberately the same NUMBER — the door replaced `cancel`