bareloop 0.12.0 → 0.14.0

package/types/reuse.d.ts

@@ -364,6 +364,7 @@ export function resumeTreeGate({ head, seed, dirty }: {
  * @param {number} [opts.strikeLimit] forwarded (a plan step's strike ceiling)
  * @param {number} [opts.closeTimeoutMs] forwarded
  * @param {boolean} [opts.layerRoot] forwarded
+ * @param {boolean|'cap'|'diff'} [opts.readShim] the read shim's ARM (A0/A1/A2/A3), forwarded verbatim
  * @param {any} [opts.resume] RESUME (module C) — a `readResume` reading of the KILLED
  *   run's own spine. Its `approvalHash` must match this run's, or the run refuses:
  *   a resume continues ONE signed run, not any run.
@@ -397,6 +398,7 @@ export function runReuse(opts: {
     strikeLimit?: number | undefined;
     closeTimeoutMs?: number | undefined;
     layerRoot?: boolean | undefined;
+    readShim?: boolean | "cap" | "diff" | undefined;
     resume?: any;
     runJob?: typeof shippedRunJob | undefined;
     now?: (() => number) | undefined;
@@ -587,6 +589,28 @@ export const REUSE_GRADED_RED: readonly string[];
  * how they would come to disagree about which member is which: the first three are
  * allowances the loop's remaining tries are meant to spend against, and the human
  * ones are the stop no further try can change (see `hardStop`).
+ *
+ * `provider-red` folded in 2026-08-25 (PRD v1.80 TODO #4, F115 "Ruled: one transport
+ * retry"; hamr's ruling verbatim: *"joins resume anyways and you decide but you are
+ * given an honest readout and with 1 retry"*). It is a MACHINE halt, not a human one
+ * — it does NOT go into `HUMAN_CHECKPOINTS` — but it is a checkpoint by the same
+ * test every other member here passes: the close never got the say it was asked
+ * for (no verdict was rendered, so it is not a graded red — see `REUSE_GRADED_RED`
+ * above), and the scout+draft and every finished step it bought stand on disk
+ * exactly like a cap-halt or a wall-halt. The one transport retry
+ * (`src/planrun.js`'s `withTransportRetry`) already covers the common case; when
+ * that retry ALSO fails, throwing the run away because the transport hiccuped
+ * twice is throwing away real work for no reason a machine can judge. Deliberately
+ * NO cost/step threshold gates this: a threshold is a number picked from a small
+ * observed sample (F115 logged exactly 7 rows), which is arbiter territory
+ * reserved for hamr — the operator decides case by case, every time, off the
+ * honest readout `scripts/run-u.mjs` prints.
+ *
+ * This entry was built 2026-08-24 as a LOCAL widening in `scripts/run-u.mjs`
+ * (`RESUMABLE_HALTS = [...CHECKPOINT_OUTCOMES, 'provider-red']`) because this file
+ * sat outside that pass's scope — the fold here is the follow-up, so this repo
+ * does not end up with two lists that can drift, which is the exact failure this
+ * constant exists to end (see the paragraph above).
  */
 export const CHECKPOINT_OUTCOMES: readonly string[];
 /**

package/types/run.d.ts

@@ -97,6 +97,19 @@
  *   collision walk would mint a `-2` beside the work the resume exists to continue. The
  *   fold's precedent exactly: the chain's state is DECLARED, never re-derived. Forwarded
  *   verbatim to the plan flow; absent is the cold path.
+ * @param {boolean|'cap'|'diff'} [opts.readShim=false] THE READ SHIM (src/readshim.js) —
+ *        WHICH ARM to run, threaded to the plan flow. The Phase 2 pre-registration's four:
+ *          `false`  A0 — off (the default)
+ *          `'cap'`  A1 — cap + pointer + next-unseen-slice + G1, no diff
+ *          `'diff'` A2 — the diff lever alone: no cap, no pointer, no G1
+ *          `true`   A3 — every lever
+ *        Anything else THROWS below, before a token is spent: a mis-spelled arm coerced
+ *        by truthiness into A3 would run one treatment under another's label and be
+ *        invisible in the results afterwards.
+ *        OFF is byte-identical to the pre-shim run in every observable (G1 included): the
+ *        frozen A0 baseline arm has to be exactly today, so a guard firing under a disabled
+ *        shim would make the baseline a treatment arm. The default-flip belongs to a
+ *        paid contrast nobody has approved yet (the `layerRoot` precedent, F41).
  * @param {boolean} [opts.layerRoot=false] Layer R (within-run ratchet) — shell
  *        territory, threaded to the plan flow. Defaults OFF
  *        (decided 2026-07-21): fixation is extinct on every current job (F41), so
@@ -128,7 +141,7 @@
  *   'interpreter-red' | 'cap-halt' | 'wall-halt' | 'step-stalled' |
  *   'hitl-pause' | 'hitl-decision-red' | `step-red:<id>`
  */
-export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, layerRoot, bridge, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun }: {
+export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, layerRoot, readShim, bridge, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun }: {
     approvals: unknown;
     workdir: string;
     provider: any;
@@ -159,6 +172,7 @@ export function runJob(rawSpec: object | string, { approvals, workdir, provider,
         grantUsed?: boolean;
     } | null | undefined;
     resumeBranch?: string | null | undefined;
+    readShim?: boolean | "cap" | "diff" | undefined;
     layerRoot?: boolean | undefined;
     humanRuling?: {
         decision: string;

package/types/tools.d.ts

@@ -19,8 +19,24 @@ export function strategyFor(granted: string[]): string;
  *   RESULT is invisible cannot be judged: a `ctx_get` that silently reds (stale pointer,
  *   bad range) looks exactly like one that worked, and the worker's fallback to a
  *   whole-file read looks like a free choice instead of a forced one.
+ * @param {{onStalePointer?: ((req: {file: string, path: string, startLine: number, endLine: number, detail: string}) => {text: string, outcome: string}|null)|null}} [opts]
+ *   `onStalePointer`: the read shim's stale-pointer serve, wired ONLY by a capping
+ *   arm (see `createReadShim`). Absent — every caller today except that one — this
+ *   whole seam is byte-identical to what it was, which is what keeps A0 the
+ *   untouched baseline an experiment has already run against.
  */
-export function createCtxTools(lc: any, workdir: string, emit: (type: string, data: object) => void): ({
+export function createCtxTools(lc: any, workdir: string, emit: (type: string, data: object) => void, { onStalePointer }?: {
+    onStalePointer?: ((req: {
+        file: string;
+        path: string;
+        startLine: number;
+        endLine: number;
+        detail: string;
+    }) => {
+        text: string;
+        outcome: string;
+    } | null) | null;
+}): ({
     name: string;
     description: string;
     parameters: {

package/types/transport.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Is `err` a transport-class failure — the request never produced an HTTP
+ * response? True for: a TLS fault mid-record ("bad record mac" and kin), a
+ * reset/broken/timed-out socket (ECONNRESET, EPIPE, ETIMEDOUT, ECONNREFUSED,
+ * ENETUNREACH — by code on the error itself or on `err.cause`), and
+ * `fetch failed` wrapping a network `cause`. False for anything carrying an
+ * HTTP status (`err.status`/`err.statusCode`, 4xx/5xx/429) or an explicit
+ * `err.retryable === false` — those are provider RESPONSES, not transport
+ * casualties, and bare-agent's own policy governs them unchanged.
+ * @param {any} err
+ * @returns {boolean}
+ */
+export function isTransportFailure(err: any): boolean;
+/** The fixed retry budget: ONE extra attempt after the first transport
+ * throw. Never read from a job spec or CLI flag — raising it is arbiter
+ * territory (only a code change hamr signs, never a run-time knob). */
+export const TRANSPORT_RETRIES: 1;
+/** bare-agent's `Retry.call` counts ATTEMPTS, not retries. */
+export const TRANSPORT_MAX_ATTEMPTS: number;