baldart 4.89.2 → 4.92.0

package/framework/.claude/skills/new2/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.2.0 — 2026-07-02
+
+- **Resume loop HARD-BOUNDED (Step 5.3)**: `resumeMaxAttempts = 3` con contatore
+  esplicito + stall detection (stesso set di card incomplete = stop immediato).
+  Un `degraded` persistente è un outage/blocker strutturale, non converge iterando
+  (~0–200k+ token a ciclo).
+
+## 1.1.1 — 2026-07-02
+
+- Fix B4 (location parallela in `new2.js`): il preflight creava il tracker in
+  `/tmp/batch-tracker-…` (volatile — la causa dei 2/3 run con "tracker LOST");
+  ora la location DURABILE `$(git -C $MAIN rev-parse --git-common-dir)/baldart/
+  run/…` allineata a new/SKILL.md § Context Tracking. Anche il riferimento del
+  merge allo stash Phase-0 aggiornato.
+- Cap adattivo del fan-out nei workflow review (`new-card-review.js` /
+  `new-final-review.js`): 5 → 2 al primo transient rate-limit (era fisso 3).
+
+## 1.1.0 — 2026-07-02
+
+- **Promossa a motore di default di `/new -auto`** (delegation gate v4.90.0):
+  non più solo variante sperimentale A/B. Nuovo Step 1.5 (contratto della
+  delega: grammar residua, mai `-auto`/`-auto-ship`/`-inline`; batch delegati
+  sempre migration-free — trovare una migrazione dichiarata su run delegata =
+  HALT + handback a `/new -inline`, mai una domanda).
+- `new2.js`: lane di fedeltà strutturale route-free per card con mockup
+  (markup-fidelity-verifier + obbligo Lane-Ledger: verifier assente →
+  `verification-coverage-gap`, card mai auto-DONE) + binding gate deterministico
+  nel brief di implement + campi cardGraph `designSrcDir`/`designHtml`/
+  `hasBindings` (T1.A).
+
 ## 1.0.0 — 2026-07-01
 
 - Baseline: versioning per-skill introdotto al framework v4.82.0.

package/framework/.claude/skills/new2/SKILL.md

@@ -1,15 +1,18 @@
 ---
 name: new2
 effort: high
-version: 1.0.0
+version: 1.2.0
 description: >
-  EXPERIMENTAL workflow-hosted variant of /new (A/B testing). Implements one or
+  Workflow-hosted batch engine for /new. Implements one or
   more backlog cards end-to-end by delegating the WHOLE batch to a background
   dynamic workflow — so subagent output never enters the main orchestrator
   context. The batch runs autonomously (zero AskUserQuestion during the run): every
   /new gate is replaced by a deterministic policy + a self-healing resolution pass;
   in interactive mode an optional post-batch escape hatch can hand the hard-case
-  follow-ups to /new for the real human gate. Claude-only (needs the Workflow tool).
+  follow-ups to /new for the real human gate. Since v4.90.0 this is ALSO the
+  default engine of `/new -auto` (its delegation gate invokes this skill when the
+  Workflow tool + new2.js are present — measured driver: 53–59% orchestrator
+  turn-tax on inline -auto runs). Claude-only (needs the Workflow tool).
   Usage: /new2 CARD-IDS (same arg grammar as /new). Triggers on:
   /new2, "implementa le card con workflow", "new2".
 ---
@@ -71,6 +74,19 @@ Also verify the workflow script is linked: if `.claude/workflows/new2.js` is abs
 print the same guidance and HALT (the framework did not link it — Codex tree, or a
 pre-v4.16 install).
 
+### Step 1.5 — Called by `/new -auto` (delegation note, v4.90.0)
+
+`/new`'s AUTONOMOUS OFF-CONTEXT DELEGATION GATE invokes this skill with the same
+residual grammar (card IDs + `-full` + `-stats` + `effort=`) — never
+`-auto`/`-auto-ship`/`-inline` (this skill IS autonomous by contract; the
+`AUTO_SHIP` deploy boundary stays in `/new`'s classic path). `/new` only
+delegates **migration-free** batches (it probes `migration_plan.required`
+itself), so Step 3.5's one interactive question cannot fire on a delegated run —
+if you nonetheless find a declared, unapplied migration in a delegated batch,
+HALT and hand back to `/new` classic (`"batch con migrazione dichiarata — riesegui
+/new <cards> -auto -inline"`) instead of asking. Everything else is identical to a
+direct `/new2` invocation.
+
 ### Step 2 — Parse the invocation (same grammar as `/new`)
 
 Parse `CARD-IDS` exactly as `/new` does — space-separated, hyphen-range
@@ -239,11 +255,22 @@ returns when the batch is done. It returns:
    prints nothing, set the epic card `status: DONE` + `completed_date` + note
    `"epic-closure gate — all children DONE (post-run, new2 skill)"`, folded into the SAME
    reconciliation commit. If any child is still open, leave the epic untouched.
-3. **Resume if degraded.** If `degraded` is true, re-invoke the workflow with
-   `Workflow({ scriptPath, resumeFromRunId })` (same `args` + the new `ts`). The
-   per-card **skip-completed** guard makes the resume idempotent — already-committed
-   cards are skipped, only the incomplete/blocked ones run. Repeat until `degraded`
-   is false (or the same cards stall twice → surface to the user).
+3. **Resume if degraded — HARD-BOUNDED (v4.92.0).** If `degraded` is true, re-invoke
+   the workflow with `Workflow({ scriptPath, resumeFromRunId })` (same `args` + the
+   new `ts`). The per-card **skip-completed** guard makes the resume idempotent —
+   already-committed cards are skipped, only the incomplete/blocked ones run.
+   Bounds (BOTH enforced, count explicitly — do not rely on remembering):
+   - **`resumeMaxAttempts = 3`** total re-invocations per batch. Keep a literal
+     counter in your working notes (`resume 1/3`, `2/3`, …); at 3 still `degraded`
+     → STOP resuming: surface `"batch stalled after 3 resumes — manual
+     intervention needed"` with the incomplete card list (their follow-ups are
+     already on disk from step 1 — nothing is lost by stopping).
+   - **Stall detection**: if a resume completes with the SAME incomplete card set
+     as the previous attempt (zero progress), stop immediately even before the
+     cap — a second identical pass will not converge either.
+   An unbounded resume loop re-pays the whole batch-loop cost per cycle (~0–200k+
+   tokens each) with no new information; a persistent `degraded` is an outage or a
+   structural blocker, not something iteration fixes.
 3b. **Escape-hatch escalation for the hard cases (INTERACTIVE mode only — the `new2`
    "relaxation").** `new2` is autonomous *during the batch* — but a genuinely-blocked
    card (the workflow rolled it back / left it `IN_PROGRESS`, DoD not met) is exactly the

package/framework/.claude/skills/ui-implement/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.1.0 — 2026-07-02
+
+- **Binding-compliance gate (Step 5b)**: nuovo script deterministico
+  `scripts/check-bindings.mjs` — ogni `component_bindings` entry `reuse`/
+  `reuse-variant` deve comparire (import o uso JSX) nei file toccati dalla build;
+  violazione = `binding-not-honored` (Critical, 1 retry a `ui-expert`, poi
+  `blocked`). Chiude il buco "la mappa è autoritativa ma nessuno verifica che la
+  build l'abbia onorata". Fail-open sugli errori interni dello script.
+- **Build-with-eyes nel briefing (Step 4)**: il brief di `ui-expert` ora porta
+  l'obbligo del self-check in-build (`ui-expert.md` § "Build-with-eyes": check
+  strutturale deterministico via `structural-compare.mjs` + check visivo con
+  screenshot Playwright quando catturabile, max 2 iterazioni, degrado onesto su
+  runtime non-multimodale) — costruisci-bene a monte invece di
+  cattura-e-ripara a valle.
+
 ## 1.0.0 — 2026-07-01
 
 - Skill introdotta (framework v4.82.0). Estrae da `/new` il playbook mockup→code

package/framework/.claude/skills/ui-implement/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: ui-implement
 effort: medium
-version: 1.0.0
+version: 1.1.0
 description: >
   Implement an ALREADY-APPROVED mockup into the codebase end-to-end and
   self-verify its fidelity. Takes a mockup in any channel — a Claude Design
@@ -123,11 +123,15 @@ Each step is a delegation. Read the cited SSOT; do not paraphrase it.
 4. **Implement — spawn `ui-expert`.** Build via the `ui-expert` agent with a
    briefing that carries: the chosen build workflow (Step 1), the mockup path(s),
    the registry-first cascade declaration requirement, the design-source
-   declaration requirement (when code-src exists), the `component_bindings`, and
-   the i18n / states-taxonomy / token-cascade constraints. All of these are
-   `ui-expert.md`'s own contracts — the briefing points at them; it does not
-   re-teach them. (Codex / no-subagents → the skill performs the build inline
-   following the same `ui-expert.md` contracts.)
+   declaration requirement (when code-src exists), the `component_bindings`, the
+   **build-with-eyes self-check obligation** (`ui-expert.md` § "Build-with-eyes"
+   — bounded structural + visual self-check BEFORE returning; the completion
+   report must carry its one-line outcome), and the i18n / states-taxonomy /
+   token-cascade constraints. All of these are `ui-expert.md`'s own contracts —
+   the briefing points at them; it does not re-teach them. (Codex /
+   no-subagents → the skill performs the build inline following the same
+   `ui-expert.md` contracts; a non-multimodal runtime degrades the visual
+   self-check to a logged skip.)
 
 5. **Ground the design-source declaration** *(only when the card has
    `links.design_src` / `mockups/_src/` exists)*. After the agent's first
@@ -137,6 +141,27 @@ Each step is a delegation. Read the cited SSOT; do not paraphrase it.
    re-spawn. Log `design-source: grounded` | `rejected (<reason>)`. (This is the
    Step 7b grounding lifted out of `/new`.)
 
+5b. **Binding-compliance gate (deterministic — only when the card carries
+   `component_bindings`).** The bindings are authoritative (Step 3), but until
+   now nothing verified the built code actually HONORED them. Run:
+
+   ```bash
+   node .claude/skills/ui-implement/scripts/check-bindings.mjs \
+     --bindings-json '<the card's component_bindings serialized to JSON>' \
+     --files <the build's touched implementation files>
+   ```
+
+   One JSON line on stdout; exit `3` = violations. Every `reuse`/`reuse-variant`
+   binding whose component appears in NO touched file (import or JSX usage) is a
+   **`binding-not-honored`** finding (Critical, UI domain): re-spawn `ui-expert`
+   ONCE with the violation list ("the binding map is authoritative — use
+   `<Component>` for region `<region>`, do not re-invent it"); still violated →
+   the card is `blocked` (this is a fidelity-contract breach, not a taste issue).
+   `action: new` entries are informational here — their governance belongs to the
+   Post-Intervention Coherence Check (Step 6). Script errors fail OPEN (`skipped`,
+   exit 0) — the gate is a safety net, never a tribunal. Log
+   `bindings: ok (N honored)` | `violations (<components>)` | `skipped`.
+
 6. **Post-Intervention Coherence Check (BLOCKING).** Reconcile the design-system
    sources in the SAME change — CITE `design-system-protocol.md`
    § "Post-Intervention Coherence Check": INDEX (`DS_INDEX_DRIFT`), component spec

package/framework/.claude/skills/ui-implement/references/integration.md

@@ -34,6 +34,9 @@ only the input source and the return shape differ.
   "findings": [ /* gating findings, canonical severity taxonomy */ ],
   "ds_drift_codes": [ "DS_INDEX_DRIFT" | "DS_COMPONENT_STALE" | "DS_TOKENS_DRIFT" ],
   "design_system_coherence": { /* INDEX / components / tokens / mirror reconciled */ },
+  "bindings": { /* Step 5b check-bindings.mjs one-line JSON (skill ≥1.1.0); absent when the card has no component_bindings */ },
+  "lane_coverage": "complete" | "incomplete",
+  "lanes": { /* forwarded from the internal /e2e-review report (skill ≥1.1.0, e2e-review ≥1.1.0) */ },
   "report_path": ".baldart/e2e-review/<id>/report.json"
 }
 ```
@@ -85,8 +88,14 @@ same opt-in contract as `/prd` → `/ds-handoff`.
 ## `new2` (workflow) note
 
 `new2.js` hosts the batch in a background workflow and reads `implement.md` /
-`review-cycle.md` for the per-card semantics. In this release `new2` keeps its
-**inline** implement+verify path (the fallback prose stays valid), so no `new2.js`
-change is required. Full `new2` parity — delegating the UI card's implement+verify
+`review-cycle.md` for the per-card semantics. `new2` keeps its **inline**
+implement path (the fallback prose stays valid), with two T1.A parallels wired in
+directly (v4.90.0): the mockup card's implement brief carries the
+**binding-compliance gate** (same `check-bindings.mjs` script as Step 5b), and a
+**route-free structural fidelity lane** (`markup-fidelity-verifier`) runs after
+implement for every card with a code-form mockup — its Lane-Ledger obligation
+(`design-system-protocol.md` § 6): verifier unavailable → `verification-coverage-gap`
+residual, the card cannot auto-DONE. Browser lanes (visual/quality) remain
+`/new`-path only. Full `new2` parity — delegating the UI card's implement+verify
 off-context via `workflow()` — is a follow-up, to be taken after the context-economy
 measurement (`SKILL.md` scope note + the plan's measure-first gate).

package/framework/.claude/skills/ui-implement/scripts/check-bindings.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+// check-bindings.mjs — deterministic `binding-not-honored` gate (T1.A, framework v4.90.0).
+//
+// A card's `component_bindings` (card-schema.md § component_bindings) is AUTHORITATIVE
+// over the mockup: each `action: reuse | reuse-variant` entry promises that the bound
+// registry component is actually USED in the implementation. Until now nothing verified
+// that promise after the build — a ui-expert that ignored a binding and re-invented the
+// primitive sailed through (the verifier trio checks fidelity-to-mockup, not
+// binding-compliance). This script closes that gap without a model call.
+//
+// Contract:
+//   node check-bindings.mjs --bindings-json '<json array>' --files <f1> <f2> ...
+//   node check-bindings.mjs --bindings-file <path.json>    --files <f1> <f2> ...
+//
+//   - `--bindings-json` is the card's `component_bindings` serialized to JSON by the
+//     caller (the orchestrator/agent already has the card in context; YAML parsing is
+//     deliberately NOT re-implemented here — the deterministic part is the code check).
+//   - `--files` are the implementation files the card touched (the build's scopeFiles).
+//   - Prints ONE JSON line to stdout:
+//       { status: "ok" | "violations" | "skipped",
+//         checked, honored, violations:[{component, region, action}],
+//         results:[{component, region, action, status, matched_in:[...]}] }
+//   - Exit codes: 0 = ok/skipped (nothing to gate), 3 = violations (gate fires).
+//     Internal errors NEVER crash the caller: fail-open → {status:"skipped"} exit 0
+//     (same philosophy as the framework-edit-gate: a safety net, not a tribunal).
+//
+// Matching rule (deterministic, conservative — prefer false-negative over false-block):
+//   an entry with action reuse/reuse-variant is HONORED when the component identifier
+//   appears in ≥1 provided file as an import specifier OR a JSX opening tag
+//   (`<Component` / `<NS.Component`). `action: new` entries are reported as
+//   informational (`new-component`) and never count as violations here — the
+//   Post-Intervention Coherence Check owns their governance.
+
+import fs from 'node:fs';
+
+function emit(obj, code) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+  process.exit(code);
+}
+
+function parseArgs(argv) {
+  const a = { bindingsJson: null, bindingsFile: null, files: [] };
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === '--bindings-json') a.bindingsJson = argv[++i];
+    else if (argv[i] === '--bindings-file') a.bindingsFile = argv[++i];
+    else if (argv[i] === '--files') {
+      while (i + 1 < argv.length && !argv[i + 1].startsWith('--')) a.files.push(argv[++i]);
+    }
+  }
+  return a;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  let raw = args.bindingsJson;
+  if (!raw && args.bindingsFile) {
+    if (!fs.existsSync(args.bindingsFile)) emit({ status: 'skipped', reason: 'bindings file not found: ' + args.bindingsFile }, 0);
+    raw = fs.readFileSync(args.bindingsFile, 'utf8');
+  }
+  if (!raw) emit({ status: 'skipped', reason: 'no --bindings-json / --bindings-file' }, 0);
+
+  let bindings;
+  try { bindings = JSON.parse(raw); } catch (e) { emit({ status: 'skipped', reason: 'bindings JSON unparsable: ' + e.message }, 0); }
+  if (!Array.isArray(bindings) || bindings.length === 0) emit({ status: 'ok', checked: 0, honored: 0, violations: [], results: [], note: 'no bindings to check' }, 0);
+
+  const sources = [];
+  for (const f of args.files) {
+    try {
+      if (fs.existsSync(f) && fs.statSync(f).isFile()) sources.push({ path: f, text: fs.readFileSync(f, 'utf8') });
+    } catch { /* unreadable file → treated as absent, fail-open per-file */ }
+  }
+  if (sources.length === 0) emit({ status: 'skipped', reason: 'no readable implementation files passed via --files' }, 0);
+
+  const results = [];
+  for (const b of bindings) {
+    const component = String(b.component || b.name || '').trim();
+    const action = String(b.action || 'reuse').trim();
+    const region = String(b.region || '').trim();
+    if (!component) { results.push({ component: '(missing)', region, action, status: 'skipped-malformed', matched_in: [] }); continue; }
+    if (action === 'new') { results.push({ component, region, action, status: 'new-component', matched_in: [] }); continue; }
+
+    // Import specifier or JSX opening tag, word-bounded. Conservative: any hit counts.
+    const esc = component.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const importRe = new RegExp(`import[^;]*\\b${esc}\\b[^;]*from`, 'm');
+    const jsxRe = new RegExp(`<(?:[A-Za-z_$][\\w$]*\\.)?${esc}[\\s/>]`);
+    const bareRe = new RegExp(`\\b${esc}\\b`);
+    const matched = sources.filter((s) => importRe.test(s.text) || jsxRe.test(s.text) || (/\.(css|scss)$/.test(s.path) && bareRe.test(s.text)));
+    results.push({
+      component, region, action,
+      status: matched.length ? 'honored' : 'not-found',
+      matched_in: matched.map((s) => s.path),
+    });
+  }
+
+  const violations = results.filter((r) => r.status === 'not-found').map(({ component, region, action }) => ({ component, region, action }));
+  const honored = results.filter((r) => r.status === 'honored').length;
+  emit(
+    { status: violations.length ? 'violations' : 'ok', checked: results.length, honored, violations, results },
+    violations.length ? 3 : 0
+  );
+}
+
+try { main(); } catch (e) { emit({ status: 'skipped', reason: 'internal error: ' + (e && e.message) }, 0); }

package/framework/.claude/workflows/new-card-review.js

@@ -46,18 +46,28 @@ const protocolRef = '.claude/skills/new/references/review-cycle.md'
 // (kills agents mid-work). Cap concurrent agents at 3 — a rolling worker pool (NOT chunked barriers,
 // which would block fast finders behind the slow background Codex poll). Mirrors the team-mode coder
 // cap so review + implementation obey the same ceiling.
-const MAX_PARALLEL = 3
-async function parallelCapped(thunks, cap) {
+// ADAPTIVE since v4.91.0 (mirrors new-final-review.js): start at 5; on the FIRST rate-limit
+// transient anywhere in the run drop to 2 (below the old fixed 3 — when the shared org limit
+// is hot, narrower is what keeps reviewers alive; when it is not, the fixed cap was pure
+// queue-wait tax). Surplus workers retire at their next pickup.
+const CAP = { value: 5 }
+const MAX_PARALLEL = CAP.value // kept for arg-compat at call sites; capNow() is authoritative
+const capNow = () => CAP.value
+function noteRateLimitPressure(src) {
+  if (CAP.value > 2) { CAP.value = 2; log(`parallelCapped: rate-limit transient (${src}) → cap 5→2 for the rest of the run`) }
+}
+async function parallelCapped(thunks, _cap) {
   if (!Array.isArray(thunks) || !thunks.length) return []
   const results = new Array(thunks.length)
   let next = 0
-  const worker = async () => {
+  const worker = async (idx) => {
     while (next < thunks.length) {
+      if (idx >= capNow()) return // adaptive shrink
       const i = next++
       try { results[i] = await thunks[i]() } catch (_) { results[i] = null }
     }
   }
-  await Promise.all(Array.from({ length: Math.min(cap, thunks.length) }, worker))
+  await Promise.all(Array.from({ length: Math.min(capNow(), thunks.length) }, (_, idx) => worker(idx)))
   return results
 }
 
@@ -79,7 +89,11 @@ async function agentSafe(prompt, opts, maxAttempts) {
     try {
       const o = i === 0 ? opts : Object.assign({}, opts, { label: `${(opts && opts.label) || 'agent'}~retry${i}` })
       return await agent(prompt, o)
-    } catch (e) { lastErr = e; if (!isTransient(e)) throw e } // permanent error → surface
+    } catch (e) {
+      lastErr = e
+      if (!isTransient(e)) throw e // permanent error → surface
+      noteRateLimitPressure((opts && opts.label) || 'agent') // v4.91.0 — shrink the pool for the rest of the run
+    }
   }
   const err = new Error('transient-exhausted: ' + String((lastErr && lastErr.message) || lastErr))
   err.transientExhausted = true

package/framework/.claude/workflows/new-final-review.js

@@ -53,22 +53,33 @@ const editableFiles = Array.isArray(a.editableFiles) ? a.editableFiles.filter(Bo
 const tcCmds = (cfg.toolchain && cfg.toolchain.commands) || {}
 const tc = (key, fallback) => (tcCmds[key] && String(tcCmds[key]).trim()) || fallback
 
-// Concurrency cap (v4.53.6 — API rate-limit guardrail; mirrors new-card-review.js + the team-mode
-// coder cap). The org-level rate limit is SHARED across every terminal/session; a wide agent fan-out
-// saturates it and the server throttles. Cap concurrent agents at 3 via a rolling worker pool (NOT
-// chunked barriers — those would block fast finders behind the slow background Codex poll).
-const MAX_PARALLEL = 3
-async function parallelCapped(thunks, cap) {
+// Concurrency cap (v4.53.6 guardrail, ADAPTIVE since v4.91.0 — mirrors new-card-review.js + the
+// team-mode coder cap). The org-level rate limit is SHARED across every terminal/session; a wide
+// agent fan-out saturates it and the server throttles (the v4.66.0 transient-kill class). The old
+// fixed cap of 3 protected against that but taxed EVERY run's wall-clock, including the majority
+// with no rate pressure (measured: review fan-out ≈ 50 min on a small batch, mostly queue wait).
+// Adaptive policy: start at 5; on the FIRST rate-limit transient seen anywhere in the run, drop to
+// 2 for the remainder (BELOW the old cap — when the org limit is hot, narrower is what saves the
+// reviewers). Rolling worker pool (NOT chunked barriers — those would block fast finders behind
+// the slow background Codex poll); workers above the current cap retire at their next pickup.
+const CAP = { value: 5 }
+const MAX_PARALLEL = CAP.value // kept for arg-compat at call sites; capNow() is authoritative
+const capNow = () => CAP.value
+function noteRateLimitPressure(src) {
+  if (CAP.value > 2) { CAP.value = 2; log(`parallelCapped: rate-limit transient (${src}) → cap 5→2 for the rest of the run`) }
+}
+async function parallelCapped(thunks, _cap) {
   if (!Array.isArray(thunks) || !thunks.length) return []
   const results = new Array(thunks.length)
   let next = 0
-  const worker = async () => {
+  const worker = async (idx) => {
     while (next < thunks.length) {
+      if (idx >= capNow()) return // adaptive shrink: retire surplus workers at pickup time
       const i = next++
       try { results[i] = await thunks[i]() } catch (_) { results[i] = null }
     }
   }
-  await Promise.all(Array.from({ length: Math.min(cap, thunks.length) }, worker))
+  await Promise.all(Array.from({ length: Math.min(capNow(), thunks.length) }, (_, idx) => worker(idx)))
   return results
 }
 
@@ -91,7 +102,11 @@ async function agentSafe(prompt, opts, maxAttempts) {
     try {
       const o = i === 0 ? opts : Object.assign({}, opts, { label: `${(opts && opts.label) || 'agent'}~retry${i}` })
       return await agent(prompt, o)
-    } catch (e) { lastErr = e; if (!isTransient(e)) throw e } // permanent error → surface
+    } catch (e) {
+      lastErr = e
+      if (!isTransient(e)) throw e // permanent error → surface
+      noteRateLimitPressure((opts && opts.label) || 'agent') // v4.91.0 — shrink the pool for the rest of the run
+    }
   }
   const err = new Error('transient-exhausted: ' + String((lastErr && lastErr.message) || lastErr))
   err.transientExhausted = true

package/framework/.claude/workflows/new2.js

@@ -203,6 +203,12 @@ const PREFLIGHT_SCHEMA = {
           // F-016 — ACs whose only implementation file is outside the card MAY-EDIT,
           // pre-classified deferred-by-policy (never routed to resolve).
           policyDeferredACs: { type: 'array', items: { type: 'object', additionalProperties: true } },
+          // T1.A (v4.90.0) — the mockup's code-form sources, so the workflow can run the
+          // route-free structural fidelity lane (markup-fidelity-verifier) without
+          // re-reading the card. Empty string when absent.
+          designSrcDir: { type: 'string', description: "abs path of links.design_src / mockups/_src dir ('' when absent)" },
+          designHtml: { type: 'string', description: "abs path of an .html links.design mockup ('' when absent)" },
+          hasBindings: { type: 'boolean', description: 'card carries a non-empty component_bindings map' },
         },
       },
     },
@@ -277,7 +283,7 @@ try {
   preflight = await agentSafe(
     `You are the deterministic PRE-FLIGHT for an autonomous /new batch (variant new2). Follow ${REF}/setup.md (Phase 0 + Pre-flight) and ${REF}/implement.md (Phase 1 depends-on gate) for the SEMANTICS, but replace EVERY AskUserQuestion with the deterministic policy below. You run all git/bash yourself (the workflow cannot).\n\n` +
       `${projectBrief}\n\nCards in batch (Read each YAML):\n${cardPaths.join('\n')}\nCard IDs: ${cardIds.join(' ')}\n\n` +
-      `Create/maintain the recovery tracker at /tmp/batch-tracker-${firstCard}.md (per setup.md § Context Tracking).\n\n` +
+      `Create/maintain the recovery tracker at "$(git -C ${MAIN} rev-parse --git-common-dir)/baldart/run/batch-tracker-${firstCard}.md" (mkdir -p its dir first; per setup.md § Context Tracking — DURABLE location, v4.91.0: /tmp is volatile and a paused/overnight run lost it — B4).\n\n` +
       `ROLE BOUNDARY (specialization integrity): you are the OPS/GIT agent. You NEVER edit source or doc files — any needed content change belongs to the coder specialist; report it instead.\n\n` +
       `DETERMINISTIC GATE POLICIES (NO user prompts):\n` +
       `• G1 dirty-tree (main repo ${MAIN}): partition framework-managed noise exactly as setup.md step 3 ($METRICS=${METRICS}, .baldart/generated|state.json|skill-conflicts.json — NOT overlays/). Genuine user work → auto-stash 'baldart-new2-${firstCard}' (main checkout) and record the label. Never commit/abort/prompt.\n` +
@@ -286,7 +292,7 @@ try {
       g3Bullet +
       `• G4 card-field validation (setup.md 1b/1c, card-schema.md consumer contract): card missing acceptance_criteria/files_likely_touched/scope → EXCLUDE (excluded[] + reason). \`requirements\` is CONDITIONAL, not an auto-exclude: if it is missing BUT acceptance_criteria + scope are both present and non-empty, FAITHFULLY DERIVE it (a concrete restatement/decomposition of the existing AC + scope — faithful, never inventing new scope) and WRITE it back to the card YAML on disk in ${MAIN}/${paths.backlog_dir || 'backlog'} (F-040: main repo, not the worktree copy; the card artifact is NOT a source/doc file, so this is allowed despite the role boundary), logging \`[BACKFILL] <id>: requirements=<N items, AC+scope-derived>\`. Only EXCLUDE for missing requirements when acceptance_criteria OR scope is ALSO empty (a genuinely thin card). Never HALT for one bad card.\n` +
       `• G5 depends-on: a card whose depends_on names a non-DONE card NOT in this batch → EXCLUDE it AND every in-batch card that transitively depends on it.\n` +
-      `• cardGraph (REQUIRED, F-021): for every runnable card return { id, dependsOn:[IN-BATCH deps only], ownerAgent (the card's owner_agent; G25 unknown→'coder'), hasMockup (BOOLEAN — true IFF the card has a non-empty links.design OR links.design_src; drives the mockup-first build override — implement.md §6a), reviewProfile (the card's review_profile; default 'balanced'), policyDeferredACs, alreadyCommitted, alreadyCommittedSha, isEpic (implement.md §6b epic guard: id ends '-00' OR filename ends '-epic.yml' OR group.is_epic:true OR review_profile 'skip' with no requirements), filesLikelyTouched (verbatim from the YAML) }.\n` +
+      `• cardGraph (REQUIRED, F-021): for every runnable card return { id, dependsOn:[IN-BATCH deps only], ownerAgent (the card's owner_agent; G25 unknown→'coder'), hasMockup (BOOLEAN — true IFF the card has a non-empty links.design OR links.design_src; drives the mockup-first build override — implement.md §6a), designSrcDir (ABS path of links.design_src / the PRD mockups/_src dir; '' when absent), designHtml (ABS path when links.design is an .html file; '' otherwise), hasBindings (BOOLEAN — non-empty component_bindings), reviewProfile (the card's review_profile; default 'balanced'), policyDeferredACs, alreadyCommitted, alreadyCommittedSha, isEpic (implement.md §6b epic guard: id ends '-00' OR filename ends '-epic.yml' OR group.is_epic:true OR review_profile 'skip' with no requirements), filesLikelyTouched (verbatim from the YAML) }.\n` +
       `• B1/F-026 idempotency (per card, AFTER the worktree exists): set alreadyCommitted:true (+ alreadyCommittedSha) IFF ALL hold: (a) a commit referencing the card id exists in ${TRUNK}..HEAD of the worktree; (b) the card's validation_commands re-run GREEN right now; (c) NO open follow-up card for it exists in ${paths.backlog_dir || 'backlog'}. On a FRESH worktree ${TRUNK}..HEAD is empty → all false, zero extra work.\n` +
       `• F-016 AC↔ownership consistency: for each acceptance_criterion, derive the file(s) it requires editing. If those files are NOT a subset of the card's MAY-EDIT/files_likely_touched → add the AC to policyDeferredACs:[{n,text,owningCard|owningFile,reason}] (it will become ONE follow-up, never a resolve). Do the same for any AC whose remedy is an owner-gated infra action (remote db push / deploy / secret / DNS).\n` +
       (migrationApplied
@@ -594,10 +600,15 @@ async function runCard(cardId, cardPath) {
   const phase1Brief = architectOk
     ? `Phase 1 already ran as specialist agents. READ the architecture baseline at ${baselinePath} BEFORE writing any code — it is your codebase context; do NOT redo the exploration.${auditCorrections.length ? `\nPlan-audit corrections (apply them as amendments to this briefing — do NOT modify the backlog YAML):\n${auditCorrections.map((c, i) => `  ${i + 1}. ${c}`).join('\n')}` : ''}`
     : `Phase 1 fallback: the architect specialist was unavailable — do the Phase 1 claim+architect exploration yourself per ${REF}/implement.md and persist the baseline to ${baselinePath} before coding.`
+  // T1.A (v4.90.0) — mockup cards: binding-compliance is verified deterministically by the
+  // check-bindings.mjs script (ui-implement Step 5b is the SSOT; this is the new2 parallel).
+  const bindingBit = node.hasMockup && node.hasBindings
+    ? `\nBINDING GATE (deterministic — ui-implement Step 5b parallel): after building, run \`node "$(ls .claude/skills/ui-implement/scripts/check-bindings.mjs .framework/framework/.claude/skills/ui-implement/scripts/check-bindings.mjs 2>/dev/null | head -1)" --bindings-json '<the card component_bindings as JSON>' --files <your touched implementation files>\`. Exit 3 = a reuse/reuse-variant binding is NOT used in the code: the map is AUTHORITATIVE — fix it before returning (one pass). Include the script's one-line JSON output as bindingCheck in your return.\n`
+    : ''
   let impl
   try {
     impl = await agentSafe(
-      `Implement card ${cardId} per ${REF}/implement.md Phase 2 — you ARE the owner_agent '${ownerAgent}' — and ${REF}/completeness.md (Phase 2.5 + 2.5b AC-closure ledger). Run all gates/bash yourself.\n\n${phase1Brief}\n\n${cardBrief}\n\n` +
+      `Implement card ${cardId} per ${REF}/implement.md Phase 2 — you ARE the owner_agent '${ownerAgent}' — and ${REF}/completeness.md (Phase 2.5 + 2.5b AC-closure ledger). Run all gates/bash yourself.\n${bindingBit}\n${phase1Brief}\n\n${cardBrief}\n\n` +
         `POLICIES: G26 Phase-2 lint/tsc/test/build failing after the module's retry cap → buildBlocked:true + blockedGate. Build the AC Closure Ledger (one row per AC: implemented|unmet|policy-deferred). DO NOT silently defer; report unmet rows (excluding policy-deferred). Persist the diff to /tmp/diff-${cardId}.txt.\n\n` +
         `E4 OWNERSHIP RECONCILE (implement.md §11b — do this BEFORE returning): the card's MAY-EDIT includes files_likely_touched ∪ paths NAMED EXPLICITLY in this card's acceptance_criteria/definition_of_done (e.g. an ADR the DoD says to update, the data-model / ER doc for a schema change). Editing THOSE is in-scope. For any OTHER dirty file outside MAY-EDIT (another card's file, or unrelated): \`git checkout -- <file>\` to revert it (NEVER leave it orphaned), list it in revertedOutOfOwnership. Set fileDiffViolation:true ONLY if such an edit genuinely could not be reverted (then say why in note) — it is no longer a silent label.\n\n` +
         `Return: { epic, buildBlocked, blockedGate, unmetACs:[{n,text}], scopeFiles, mayEditPaths, revertedOutOfOwnership:[paths], fileDiffViolation, note }`,
@@ -642,6 +653,41 @@ async function runCard(cardId, cardPath) {
     if (r.status !== 'resolved') { deferredOpen = true; deferredClasses.add(r.deferralClass || 'unresolved') }
   }
 
+  // --- T1.A (v4.90.0): route-free structural fidelity lane — the new2 parallel of
+  // /e2e-review Phase 2.7. new2 has NO browser lanes (visual/quality verify runs only on
+  // the /new path), so the code-form structural check is its ONE per-card fidelity lane.
+  // Running it is a Lane-Ledger obligation (design-system-protocol § 6. Verification-Lane
+  // Ledger): a mockup card with a code-form source may NOT complete with zero fidelity
+  // verification (the FEAT-0064 under-run). Verifier unavailable → verification-coverage-gap
+  // residual + the card cannot be auto-DONE — an under-run blocks, never passes silently.
+  if (node.hasMockup && (node.designSrcDir || node.designHtml)) {
+    const structSrc = node.designSrcDir
+      ? { level: 'design_src', design_src_dir: node.designSrcDir }
+      : { level: 'html', mockup_path: node.designHtml }
+    let mfv = null
+    try {
+      mfv = await agentSafe(
+        `Compare the implementation's code structure against the mockup's code structure and return JSON per your output schema (route-free — no browser, no dev server; cd into ${sharedCtx.worktreePath}).\n\nInput payload:\n${JSON.stringify({ card_id: cardId, route: '(card-level)', mockup_source: structSrc, implementation_files: scopeFiles, tolerance: 'strict' })}\n\nReturn STRICT JSON only: { findings:[{category,severity,description,expected,actual,fix_hint}] }`,
+        { label: `fidelity:${cardId}:structural`, phase: 'Implement', agentType: 'markup-fidelity-verifier',
+          schema: { type: 'object', required: ['findings'], additionalProperties: true, properties: { findings: { type: 'array', items: { type: 'object', additionalProperties: true } } } } }
+      )
+    } catch (e) {
+      if (e && e.transientExhausted) noteDegraded('outage')
+    }
+    if (!mfv) {
+      g('fidelity-structural', 'UNDERRUN', 'planned lane never executed (verifier unavailable) — verification-coverage-gap, card cannot auto-DONE')
+      deferredOpen = true; deferredClasses.add('unresolved')
+      residuals.push({ card: cardId, kind: 'verification-coverage-gap', evidence: 'structural fidelity lane planned but not executed (markup-fidelity-verifier unavailable)', materialized: false })
+    } else {
+      const gating = (mfv.findings || []).filter((f) => /critical|major/i.test(String(f.severity || '')))
+      g('fidelity-structural', gating.length ? 'BLOCKED' : 'PASS', gating.length ? `${gating.length} gating structural finding(s)` : `ran — ${(mfv.findings || []).length} finding(s), none gating`)
+      for (const f of gating) {
+        const r = await resolve('blocker', cardId, `structural fidelity (${f.category || 'layout'}): ${f.description || ''} — expected: ${f.expected || '(see mockup)'}`, { mayEditPaths: mayEdit, scopeFiles, domain: 'ui' })
+        if (r.status !== 'resolved') { deferredOpen = true; deferredClasses.add(r.deferralClass || 'unresolved') }
+      }
+    }
+  }
+
   // --- Review fan-out (F-024/F-025): specialized agents, trimmed by review_profile. ---
   // G5 — scopeFiles tokens alone miss a security card whose files don't carry them. Also
   // trigger security-reviewer on the card's RAW owner_agent and its brief (title/requirements).
@@ -1106,7 +1152,7 @@ if (!committed.length) {
 } else {
   try {
     mergeResult = await agentSafe(
-      `Auto-merge the batch worktree to ${TRUNK} per ${REF}/merge-cleanup.md: Phase 6 via the DETERMINISTIC script merge-worktree.sh, then Phase 6b status reconciliation + Phase 6c hygiene. Run git yourself.\n\n${projectBrief}\nWorktree: ${sharedCtx.worktreePath}\nBranch: ${sharedCtx.branch}\nmerge_strategy: ${mergeStrategy}\nCommitted cards: ${committed.map((r) => r.card).join(' ')}\nPhase-0 stash to restore (if any): see /tmp/batch-tracker-${firstCard}.md.\n\n` +
+      `Auto-merge the batch worktree to ${TRUNK} per ${REF}/merge-cleanup.md: Phase 6 via the DETERMINISTIC script merge-worktree.sh, then Phase 6b status reconciliation + Phase 6c hygiene. Run git yourself.\n\n${projectBrief}\nWorktree: ${sharedCtx.worktreePath}\nBranch: ${sharedCtx.branch}\nmerge_strategy: ${mergeStrategy}\nCommitted cards: ${committed.map((r) => r.card).join(' ')}\nPhase-0 stash to restore (if any): see "$(git -C ${MAIN} rev-parse --git-common-dir)/baldart/run/batch-tracker-${firstCard}.md".\n\n` +
         `PHASE 6 — run the SSOT script (the merge analogue of setup-worktree.sh; NOT a hand-rolled merge, NOT /mw inline):\n` +
         `  MERGE_SH="$(ls .framework/framework/.claude/skills/worktree-manager/scripts/merge-worktree.sh .claude/skills/worktree-manager/scripts/merge-worktree.sh 2>/dev/null | head -1)"\n` +
         `  bash "$MERGE_SH" --worktree ${sharedCtx.worktreePath} --manifest /tmp/new2-merge-status-${firstCard}.txt --skip-checks\n` +

package/framework/agents/code-search-protocol.md

@@ -91,6 +91,30 @@ Before picking a tier, classify the query:
   ~8–12M tokens with three coders independently re-discovering one NUL byte in a
   single multi-hundred-KB `data.ts`.)
 
+## Large-file read discipline (hot files)
+
+A **hot file** is any source file **> 800 lines** that multiple agents touch in the
+same run (a form client, a data layer, a locale dictionary). Forensics on real
+`/new` batches showed hot-file FULL re-reads are the dominant repeated-read cost —
+NOT the framework modules (read 1× each): one 2110-line client component (~29k
+tokens per full view) was read **28 times** across architect → coder → fixer →
+verifier spawns in a single run, because each fresh context re-read it whole.
+
+Rules (every agent, every runtime):
+
+1. **Map once, range-read after.** The `codebase-architect` baseline carries a
+   `## Hot-File Map` for every in-scope file > 800 lines (per-symbol line ranges —
+   see `codebase-architect.md` § terse contract). When you need a hot file and a
+   map exists, `Read` the **target range only** (offset/limit around the symbol),
+   never the whole file.
+2. **No map → locate first, then range-read.** `rg -n "<symbol>"` (or LSP
+   go-to-definition when the flag is on) to find the line, then `Read` a bounded
+   window around it. A whole-file `Read` of a hot file is justified ONLY when the
+   edit genuinely spans dispersed regions of it — say so in one line when you do it.
+3. **Briefs pass paths, not bodies.** An orchestrator briefing an agent passes the
+   baseline **path** (e.g. `/tmp/arch-baseline-<CARD-ID>.md`), never its inlined
+   content — and never inlines a hot file into a prompt.
+
 ## Fallback rules
 
 - LSP tool not loaded / plugin missing → silently fall back to Grep with the

package/framework/agents/design-system-protocol.md

@@ -654,6 +654,33 @@ card's `owner_agent: coder` (correct for its logic/review ownership) sent the UI
 `coder`. `owner_agent` still governs the review/ownership semantics; it just does not pick
 the build agent when a mockup is present.
 
+### 6. Verification-Lane Ledger — planned vs executed (no silent lane under-run)
+
+Checks 1–4 above each guard ONE lane. This check guards the **whole matrix**: the run
+that silently executes *fewer lanes than it planned*. The driving lesson (FEAT-0064,
+post-mortem of run `a73a52d0`): a mockup card went through "fidelity review" in which
+**only** the structural verifier ever spawned — no `visual-fidelity-verifier`, no
+`ui-quality-critic` — and nothing in the verdict recorded the under-run; the escaped
+polish surfaced later as a hand-worked bug card. A lane that is planned and then not
+executed is invisible to per-lane guards, so the ledger is reconciled globally:
+
+- **At plan time** the verifying orchestrator (`/e2e-review` Phase 2; the degraded
+  direct-trio path in `/ui-implement`; the `new2.js` structural lane) derives, per
+  route/surface, the set of REQUIRED lanes — `structural` (when a code-form mockup
+  exists), `visual` per in-scope viewport, `quality` (when a quality oracle exists),
+  `functional` (when scenarios exist) — and persists it.
+- **At verdict time** it reconciles planned vs executed. Every planned lane must be
+  `ran` or `skipped(<authorized reason>)` where the authorized reasons are ONLY the
+  ones this protocol enumerates (pixel-diff pre-filter pass, `render_unavailable` with
+  structural covered, `no_quality_oracle`, harness-render fidelity guard,
+  desktop-only route for the responsive pass). A planned lane that is simply
+  **`not_run`** synthesizes a **`verification-coverage-gap`** (Critical) — the matrix
+  twin of `coverage-gap`: not fixable by an agent, bypasses the self-heal loop, maps
+  to `blocked`. A verdict of `passed` with an unreconciled lane ledger is a protocol
+  violation, and no self-served "accepted (harness limit)" style verdict exists —
+  accepting an un-run lane requires the explicit override path (human reason) or the
+  caller's escalation, never the verifier's own discretion.
+
 ### Gating philosophy (calibration)
 
 Vision-model reliability research (*MLLM as a UI Judge*, 2025) shows multimodal judges are