bareloop 0.8.0 → 0.10.0

package/src/ledger.js

@@ -75,10 +75,22 @@ const EXCLUDED_ESCALATIONS = new Set([
   // real upstream ask would be sourced from anyway.
   'step-stalled',
   'step-variance',      // A's replan trigger: a planning story, never a lib bug
-  'gate-red',           // governance working as intended
+  // Governance working as intended — and no longer minted anywhere in this tree
+  // (a denial streak is a bounded attempt, not a terminal). Kept listed because
+  // this set is the EXECUTABLE excluded-set: dropping a name does not delete the
+  // category, it re-files any future emission of it as a counted capability gap.
+  'gate-red',
   'smoke-red',          // already counted via primitive-smoke
   'hitl-close',         // by design: a human is the close
   'close-unsupported',  // honest refusal, by design
+  // Close authoring (M4, D13) — the interview refusing a job we cannot close: a
+  // genre we do not run, a job with no seed to measure against, a locked kind.
+  // Honest refusal, exactly like `close-unsupported` above, and excluded for a
+  // SECOND reason that matters more: the demand is already counted once, as the
+  // `request-red` the same refusal emits with `lib: 'bareloop'` stamped at its
+  // emit site. Counting the escalation too would double every refusal in the one
+  // number the admission path exists to measure.
+  'close-unauthorable',
   // Layer 3 (D2 split): the bridge load gate refused a wrong-KIND recipe at the door.
   // That is the mechanism WORKING — every recipe from a different day is a candidate for
   // refusal, and the run stopped having spent nothing. Filing it upstream would aim a bug
@@ -99,6 +111,11 @@ const EXCLUDED_ESCALATIONS = new Set([
   // in the registry. Both are the operator's own state speaking (a stale signature, an
   // edited registry), and both stop having run nothing.
   'resume-red',
+  // v1.57 §3 — the work branch could not be created: the patient is not a git checkout,
+  // or its branch namespace is too crowded to find a free name. The operator's own state
+  // speaking, exactly like `registry-red` below, and the run stopped having spent nothing.
+  // Filing it upstream would aim a bug report at a library for a patient nobody prepared.
+  'branch-red',
   'registry-red',       // the operator-supplied registry path does not exist — a typo, not a bug
   'envelope-red',       // the envelope does not compose with the signed spec — operator input
   // the reuse runner also STOPS on the three answers no further try could change, and

package/src/plan.js

@@ -25,6 +25,7 @@
 // plain parsed data; every failure is a named {code, path, detail} red.
 
 import { TOOL_MENU, LOCKED_TOOLS, WRITE_VERBS, checkMenu } from './job.js';
+import { declaredStages } from './declaredclose.js';
 import { globToPrefix, scopeContained, isObj, isNonEmptyString, sweepSecretLiterals, hasNestedQuantifier } from './validate.js';
 
 /** the closed exit menu (PRD v1.12 §3 + decision 1's `check-passes`): the
@@ -170,6 +171,30 @@ export function stageClose(close) {
   return [{ name: 'close', cmd: close.cmd, expect: close.expect, judged: close.judged, gapKeep: close.gapKeep }];
 }
 
+/**
+ * THE ONE STAGING, one level up: a job's close stages, from EITHER of the two
+ * fields a spec may carry.
+ *
+ * `stageClose` reads a command close; `declaredStages` reads an authored
+ * declaration (M4). A spec declares exactly one of them — the job validator reds
+ * `close-duplicated` on both — so this is a selection, never a merge.
+ *
+ * Every consumer calls THIS rather than `stageClose` directly, for the reason
+ * W4 wrote `stageClose` in the first place: the drafting prompt, the plan
+ * validator, the runner, the bridge registry and the reuse envelope must all see
+ * the same stage list, and a consumer that reads only `close` sees a declared
+ * job as having no close at all — an empty check menu offered to a drafter whose
+ * plan the validator would then red for referencing a stage nobody offered.
+ * @param {any} job the job spec, any shape
+ * @returns {any[]|null} the stage list, or null when the job names no close
+ */
+export function closeStagesOf(job) {
+  if (!isObj(job)) return null;
+  const declared = declaredStages(job.closeDecl);
+  if (declared) return declared;
+  return stageClose(job.close);
+}
+
 /** @typedef {{code: string, path: string, detail?: string, verb?: string}} Red */
 
 /**
@@ -235,7 +260,7 @@ export function validatePlan(input, { job, maxStepRounds = 40, scopes, seedRed,
   // (gold/rubric/hitl) stages nothing, so it offers nothing — the runner
   // escalates `close-unsupported` on the same null, and an empty menu is already
   // the honest reading here (every check-passes becomes a check-unknown).
-  const checkNames = checkMenu(stageClose(spec.close) ?? []).map((m) => m.name);
+  const checkNames = checkMenu(closeStagesOf(spec) ?? []).map((m) => m.name);
   // The offered scope menu. A caller-supplied menu must be the same one the
   // prompt enumerated; with none, derive from the signed fence — fail-CLOSED,
   // so omitting the option narrows the agent's choices and never widens them.