baldart 4.92.0 → 4.92.1

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to BALDART will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.92.1] - 2026-07-02
+
+**Review avversariale post-release del motore new2 (coerenza interna).** Tre reviewer indipendenti a contesto fresco (dataflow / edge-case / contratti) sull'onda v4.90–4.92; ogni finding ri-verificato contro il codice prima di agire: **11 confermati e fixati, 9 refutati con evidenza empirica** (tra i refutati: la "race" del worker-pool adattivo — simulata: 0 buchi; `verify-item.sh` su bash 3.2 reale — funziona; `parseInt` con CRLF; un CAP attribuito a `new2.js` che non esiste).
+
+**PATCH** — hardening senza cambi di superficie. **Nessuna nuova chiave config**. **Codex parity: portable/N/A** (prosa + workflow JS Claude-only).
+
+### Fixed
+
+- **`new2.js`**: verifier strutturale che si auto-dichiara `status:"skipped"` = UNDERRUN (mai PASS — era l'ultimo canale di under-run mascherato); **re-verify deterministica** una-tantum dopo un fix strutturale risolto (il self-report del fixer non è la conferma del verifier); **`bindingCheck` consumato** (violazioni sopravvissute al pass dell'agent → resolve ui; report assente → ledger fail-open, mai silente); `${MAIN}` quotato dentro `$(git -C …)` (path con spazi).
+- **`/e2e-review` 1.2.1**: stringa lane canonica `skipped:render_unavailable_structural_covered` scritta esplicitamente da Phase 3.8 (l'assertion di Phase 5 valida l'enum chiuso); chiave di convergenza del self-heal estesa con `viewport_role`.
+- **`new2` 1.2.1**: Step 3.5 ramo AUTONOMOUS (CI/`BALDART_AUTONOMOUS`/origine delegata → mai una domanda, mai un apply command autonomo); **origine delegata = autonoma ovunque** (escape hatch 3b SKIPPED anche con TTY — chiuso il rischio di ciclo `/new`→`new2`→`/new` a costo pieno); contatore resume **durabile nel batch tracker** (una compaction non resetta il bound) + teardown broker Codex su ogni uscita per stallo.
+- **`structural-compare.mjs`**: arbitrary value Tailwind con funzioni (`grid-cols-[repeat(2,_minmax(0,1fr))]`) contati con la `countTracks` parens-aware (era `split('_')` → 3 invece di 2, falso segnale di divergenza).
+- **`ui-implement` 1.1.1**: Return Contract documenta i campi `bindings`/`lane_coverage`/`lanes` (schema SSOT in integration.md).
+
 ## [4.92.0] - 2026-07-02
 
 **Tier 3 del programma "deep analysis /new+/ui-implement": parity tripwire, bound dei loop, verifica payload new2.** Chiude il programma a 3 tier (4.90.0 → 4.92.0).

package/VERSION

@@ -1 +1 @@
-4.92.0
+4.92.1

package/framework/.claude/skills/e2e-review/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.2.1 — 2026-07-02
+
+- Phase 3.8: la lane visual del route non renderizzabile con mockup code-form viene
+  marcata esplicitamente `skipped:render_unavailable_structural_covered` nel Lane
+  Matrix (l'enum canonico che l'assertion di Phase 5 step 0 valida); `gaps[]` tiene
+  il diagnostico `render_unavailable` — due stringhe deliberatamente distinte.
+- Phase 5b step 3: chiave di convergenza estesa con `viewport_role`
+  (`route, source, category, viewport_role, region`) — una regressione
+  viewport-scoped non può più matchare falsamente il finding pre-fix.
+
 ## 1.2.0 — 2026-07-02
 
 - **Self-heal convergence detection (Phase 5b step 3)**: se il fix produce finding

package/framework/.claude/skills/e2e-review/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: e2e-review
 effort: medium
-version: 1.2.0
+version: 1.2.1
 description: >
   Deterministic, BLOCKING end-to-end review run after a feature is implemented.
   Combines functional E2E (Playwright spec written by `coder`, executed via
@@ -520,8 +520,12 @@ For each route with a mockup (`mockup_source.level != "skip"`):
    - A comparable render was produced → it is the implementation screenshot for Phase 4.
    - Still degenerate after the loop **and** the mockup is **code-form** (a Phase 2.7
      `structural_source` exists) → the structural pass already covered fidelity; record
-     `render_unavailable` in `gaps[]` and let Phase 4's visual step skip this route's
-     desktop diff (no false coverage-gap — structure was checked route-free).
+     `render_unavailable` in `gaps[]` (diagnostic), set the route's visual lane in the
+     Lane Matrix to **`skipped:render_unavailable_structural_covered`** (the canonical
+     enum the Phase 5 step 0 assertion validates — the two strings are deliberately
+     distinct: `gaps[]` carries the diagnostic, `lanes` carries the closed-set reason),
+     and let Phase 4's visual step skip this route's desktop diff (no false
+     coverage-gap — structure was checked route-free).
    - Still degenerate after the loop **and** the mockup is **image-only**
      (`level ∈ {figma, local}` with no `structural_source`) → mark the route
      `coverage_obligation_unmet = true` for Phase 4 step 1c (it will synthesize a
@@ -894,7 +898,10 @@ For each iteration:
    the Phase 4b quality pre-filter already make a clean re-run cheap.
 3. **Re-aggregate and re-decide** (back to Phase 5 step 1), with **convergence
    detection (v4.92.0)**: compare the new gating-finding set with the pre-fix one by
-   `(route, source, category, region)`. If the fix produced **NEW gating findings that
+   `(route, source, category, viewport_role, region)` — the Phase 4 step 4
+   de-duplication key extended with `source`, so a viewport-scoped regression (a fix
+   that repairs desktop while breaking the mobile pass on the same route/category) is
+   a NEW finding, never a false match. If the fix produced **NEW gating findings that
    were not present before** (the fixer is regressing while fixing — the documented
    non-convergent failure mode), do NOT burn another iteration: STOP the loop now and
    transition to the override path with both sets in the report (`convergence:

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

@@ -2,6 +2,22 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.2.1 — 2026-07-02
+
+Review avversariale post-release (3 lenti indipendenti, finding verificati):
+- **Step 3.5 ramo AUTONOMOUS**: env-autonomous / origine delegata → mai una domanda;
+  verify green ⇒ prosegui, altrimenti `degraded` (deferral owner-gated di fine batch);
+  mai un apply command autonomo.
+- **Origine delegata = autonoma ovunque** (Step 1.5): l'escape hatch 3b è SKIPPED anche
+  con TTY (niente ciclo /new→new2→/new a costo pieno inline).
+- **Contatore resume DURABILE** (Step 5.3): `resume_attempt: N/3` appeso al batch
+  tracker prima di ogni re-invocazione (una compaction non resetta il bound) +
+  teardown del broker Codex prima di ogni uscita per stallo.
+- `new2.js`: verifier strutturale `status:"skipped"` = UNDERRUN (mai PASS);
+  re-verify deterministica una-tantum dopo un fix strutturale risolto;
+  `bindingCheck` CONSUMATO (violazioni → resolve ui; assente → ledger, fail-open);
+  `${MAIN}` quotato dentro `$(git -C …)` (path con spazi).
+
 ## 1.2.0 — 2026-07-02
 
 - **Resume loop HARD-BOUNDED (Step 5.3)**: `resumeMaxAttempts = 3` con contatore

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

@@ -1,7 +1,7 @@
 ---
 name: new2
 effort: high
-version: 1.2.0
+version: 1.2.1
 description: >
   Workflow-hosted batch engine for /new. Implements one or
   more backlog cards end-to-end by delegating the WHOLE batch to a background
@@ -79,7 +79,12 @@ pre-v4.16 install).
 `/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
+`AUTO_SHIP` deploy boundary stays in `/new`'s classic path). **A delegated run is
+AUTONOMOUS-ORIGIN**: treat it exactly like the env-signalled autonomous state
+everywhere this skill branches on it — Step 3.5 resolves deterministically (its
+AUTONOMOUS branch) and **Step 3b's escape hatch is SKIPPED** (the user asked for
+`-auto`; a post-batch question — and a possible `/new` re-invocation at full
+inline cost — would break that promise even with a TTY present). `/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,
@@ -139,6 +144,14 @@ untouched), so the schema is live **before** the workflow starts. It mirrors `/n
    modalities (always include "Già applicata — prosegui" and "Abort"). This is the SAME class as the
    Step-2 "ONE pre-launch question" — pre-launch, not a mid-run gate; the zero-ask contract is about
    the *workflow*, which is untouched.
+   **AUTONOMOUS branch (v4.92.1 — env `BALDART_AUTONOMOUS` / `CI` / `GITHUB_ACTIONS`, or a
+   delegated `/new -auto` origin per Step 1.5): NEVER ask.** Resolve deterministically:
+   (a) `migration_plan.verify` exists → run it; green ⇒ treat as "Già applicata — prosegui",
+   red/absent ⇒ (b) set `migration = { status: 'degraded', reason: 'autonomous —
+   owner-gated apply deferred' }` and continue (the workflow's end-of-batch owner-gated
+   deferral handles it — a `db-migration-deploy` residual, exactly the `/new` Phase 0 1b
+   autonomous disposition). Never run an apply **command** modality autonomously (it is an
+   outward/irreversible action).
 6. **Execute the choice in `$MAIN`**:
    - **Schema-deploy-from-trunk-only guard** (when `stack.schema_deploy_from_trunk_only: true`): a
      **command** modality is a remote schema deploy → run it only from trunk. Check
@@ -260,14 +273,21 @@ returns when the batch is done. It returns:
    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).
+   - **`resumeMaxAttempts = 3`** total re-invocations per batch. The counter is
+     DURABLE, not a working note: append `resume_attempt: N/3 | <ts> | incomplete:
+     <card list>` to the batch tracker (`$(git -C "$MAIN" rev-parse
+     --git-common-dir)/baldart/run/batch-tracker-<FIRST-CARD-ID>.md`) BEFORE each
+     re-invocation — a compaction/crash between resumes must not reset the count
+     (re-read the tracker's `resume_attempt` lines to recover it). At 3 still
+     `degraded` → STOP resuming: run the **Codex broker teardown first** (the same
+     idempotent two-line block as step 6 below — a stall exit must not leak the
+     broker), then 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.
+     as the previous attempt (zero progress — compare against the tracker's last
+     `resume_attempt` line), stop immediately even before the cap — a second
+     identical pass will not converge either. Same teardown-then-surface exit.
    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.
@@ -283,8 +303,9 @@ returns when the batch is done. It returns:
    the offer is purely additive over an already-safe ledger — declining (or a closed
    terminal) never drops a residual.
    - **Skip this step entirely in AUTONOMOUS mode** (env `BALDART_AUTONOMOUS` / `CI` /
-     `GITHUB_ACTIONS` set, or no TTY) — leave the cards `IN_PROGRESS` + their follow-ups,
-     exactly as before. The escape hatch is interactive-only.
+     `GITHUB_ACTIONS` set, no TTY, **or a delegated `/new -auto` origin — Step 1.5**) —
+     leave the cards `IN_PROGRESS` + their follow-ups, exactly as before. The escape
+     hatch is interactive-only, and a delegated run is autonomous even with a TTY.
    - **Eligible set** = the follow-ups whose residual `deferralClass` is **code-actionable**:
      `unresolved`, `out-of-ownership`, `scope-expansion`. EXCLUDE `owner-gated` /
      `not-a-code-defect` / `policy-deferred-ac` (external infra steps — `/new` cannot perform

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

@@ -2,6 +2,11 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.1.1 — 2026-07-02
+
+- Return Contract (SKILL.md): documentati i campi `bindings` + `lane_coverage`/`lanes`
+  del JSON programmatico (lo schema resta SSOT in references/integration.md).
+
 ## 1.1.0 — 2026-07-02
 
 - **Binding-compliance gate (Step 5b)**: nuovo script deterministico

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

@@ -1,7 +1,7 @@
 ---
 name: ui-implement
 effort: medium
-version: 1.1.0
+version: 1.1.1
 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
@@ -233,7 +233,12 @@ older install), `/new` falls back to an inline **coarse** build brief + a direct
 
 **Mode:** COMPACT (default). Your final message is bounded — verdict
 (`passed | blocked | overridden | skipped | error`) + the chosen build workflow +
-key findings as `path:line` + `Report: <path>`. Persist the long form (the
+key findings as `path:line` + `Report: <path>`. The programmatic JSON ALSO carries
+(since 1.1.1): `bindings` (the Step 5b `check-bindings.mjs` one-line result, when
+the card has `component_bindings`) and `lane_coverage` + `lanes` (forwarded from
+the internal `/e2e-review` report) — full schema:
+[references/integration.md](references/integration.md) § Return contract (the
+SSOT; do not restate it here). Persist the long form (the
 `/e2e-review` report + tracker), return the short form. FULL narrative only when the
 user invoked you directly. Schema + persist-then-summarize rule:
 `framework/agents/return-contract-protocol.md`.

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

@@ -283,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 "$(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` +
+      `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` +
@@ -614,7 +614,7 @@ async function runCard(cardId, cardPath) {
         `Return: { epic, buildBlocked, blockedGate, unmetACs:[{n,text}], scopeFiles, mayEditPaths, revertedOutOfOwnership:[paths], fileDiffViolation, note }`,
       { label: `implement:${cardId}`, phase: 'Implement', agentType: ownerAgent,
         schema: { type: 'object', required: ['epic', 'buildBlocked', 'unmetACs', 'scopeFiles'], additionalProperties: true,
-          properties: { epic: { type: 'boolean' }, buildBlocked: { type: 'boolean' }, blockedGate: { type: 'string' }, unmetACs: { type: 'array', items: { type: 'object', additionalProperties: true } }, scopeFiles: { type: 'array', items: { type: 'string' } }, mayEditPaths: { type: 'array', items: { type: 'string' } }, revertedOutOfOwnership: { type: 'array', items: { type: 'string' } }, fileDiffViolation: { type: 'boolean' }, note: { type: 'string' } } } }
+          properties: { epic: { type: 'boolean' }, buildBlocked: { type: 'boolean' }, blockedGate: { type: 'string' }, unmetACs: { type: 'array', items: { type: 'object', additionalProperties: true } }, scopeFiles: { type: 'array', items: { type: 'string' } }, mayEditPaths: { type: 'array', items: { type: 'string' } }, revertedOutOfOwnership: { type: 'array', items: { type: 'string' } }, fileDiffViolation: { type: 'boolean' }, note: { type: 'string' }, bindingCheck: { type: 'object', additionalProperties: true, description: 'check-bindings.mjs one-line JSON (mockup+bindings cards only)' } } } }
     )
   } catch (e) {
     if (e && e.transientExhausted) { noteDegraded('outage'); return { card: cardId, status: 'pending', gates } }
@@ -653,6 +653,23 @@ async function runCard(cardId, cardPath) {
     if (r.status !== 'resolved') { deferredOpen = true; deferredClasses.add(r.deferralClass || 'unresolved') }
   }
 
+  // --- R1-F2 (v4.92.1): the binding gate result is CONSUMED, not write-only. The agent
+  // was already told to run check-bindings.mjs and fix before returning; here the workflow
+  // verifies the report: violations survive the agent's own pass → resolve (ui domain);
+  // report absent on a bindings card → fail-open but LEDGERED (audit trail, never silent).
+  if (node.hasMockup && node.hasBindings) {
+    const bc = impl && impl.bindingCheck
+    const bcViol = (bc && Array.isArray(bc.violations)) ? bc.violations : []
+    if (!bc) g('binding-gate', 'NOT-REPORTED', 'agent returned no bindingCheck — fail-open (script may be absent on older installs), recorded for audit')
+    else if (bcViol.length) {
+      g('binding-gate', 'VIOLATIONS', bcViol.map((v) => v.component).join(', '))
+      for (const v of bcViol) {
+        const r = await resolve('blocker', cardId, `binding-not-honored: region "${v.region || ''}" is bound action:${v.action || 'reuse'} → ${v.component}, but the component appears in NO touched implementation file — the binding map is authoritative (card-schema.md § component_bindings)`, { mayEditPaths: mayEdit, scopeFiles, domain: 'ui' })
+        if (r.status !== 'resolved') { deferredOpen = true; deferredClasses.add(r.deferralClass || 'unresolved') }
+      }
+    } else g('binding-gate', 'OK', `${(bc && bc.honored) || 0}/${(bc && bc.checked) || 0} bindings honored`)
+  }
+
   // --- 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.
@@ -664,26 +681,42 @@ async function runCard(cardId, cardPath) {
     const structSrc = node.designSrcDir
       ? { level: 'design_src', design_src_dir: node.designSrcDir }
       : { level: 'html', mockup_path: node.designHtml }
+    const spawnMfv = () => 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: { status, 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: { status: { type: 'string' }, findings: { type: 'array', items: { type: 'object', additionalProperties: true } } } } }
+    )
     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')
+    try { mfv = await spawnMfv() } catch (e) { if (e && e.transientExhausted) noteDegraded('outage') }
+    // R1-F1 (v4.92.1): a verifier that RETURNS but self-reports `status:"skipped"`
+    // (no_structural_ground_truth — unreadable mockup / no layout-bearing impl) is an
+    // under-run exactly like an unavailable verifier, NEVER a PASS.
+    const mfvSkipped = mfv && /skip/i.test(String(mfv.status || ''))
+    if (!mfv || mfvSkipped) {
+      g('fidelity-structural', 'UNDERRUN', `planned lane did not verify (${!mfv ? 'verifier unavailable' : 'verifier skipped: ' + String((mfv && mfv.reason) || 'no_structural_ground_truth')}) — 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 })
+      residuals.push({ card: cardId, kind: 'verification-coverage-gap', evidence: `structural fidelity lane planned but did not verify (${!mfv ? 'markup-fidelity-verifier unavailable' : 'verifier skipped'})`, materialized: false })
     } else {
-      const gating = (mfv.findings || []).filter((f) => /critical|major/i.test(String(f.severity || '')))
+      const gatingOf = (x) => ((x && x.findings) || []).filter((f) => /critical|major/i.test(String(f.severity || '')))
+      const gating = gatingOf(mfv)
       g('fidelity-structural', gating.length ? 'BLOCKED' : 'PASS', gating.length ? `${gating.length} gating structural finding(s)` : `ran — ${(mfv.findings || []).length} finding(s), none gating`)
+      let anyResolved = false
       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') }
+        else anyResolved = true
+      }
+      // R1-F3 (v4.92.1): a resolved structural fix is RE-VERIFIED by the deterministic
+      // verifier once (mirror of /e2e-review Phase 5b step 2 — a fixer's self-report is
+      // not the verifier's confirmation). Single re-check, no loop: still-gating after
+      // the re-run → deferral (the follow-up carries it), never a second fix pass here.
+      if (anyResolved) {
+        let mfvRe = null
+        try { mfvRe = await spawnMfv() } catch (e) { if (e && e.transientExhausted) noteDegraded('outage') }
+        const reGating = mfvRe && !/skip/i.test(String(mfvRe.status || '')) ? gatingOf(mfvRe) : null
+        if (reGating === null) { g('fidelity-structural-reverify', 'UNDERRUN', 're-verify did not run — treated as unresolved'); deferredOpen = true; deferredClasses.add('unresolved') }
+        else if (reGating.length) { g('fidelity-structural-reverify', 'STILL-BLOCKED', `${reGating.length} gating finding(s) survive the fix — deferred`); deferredOpen = true; deferredClasses.add('unresolved'); residuals.push({ card: cardId, kind: 'blocker', domain: 'ui', evidence: `structural fidelity still failing after fix: ${reGating.map((f) => f.category).join(', ')}`, materialized: false }) }
+        else g('fidelity-structural-reverify', 'PASS', 'fix confirmed by the verifier')
       }
     }
   }
@@ -1152,7 +1185,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 "$(git -C ${MAIN} rev-parse --git-common-dir)/baldart/run/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/scripts/structural-compare.mjs

@@ -111,9 +111,14 @@ function signature(texts) {
         sig.grid_cols_responsive_max = Math.max(sig.grid_cols_responsive_max, countTracks(m[1]));
       }
     }
-    // Tailwind: grid-cols-N (+ responsive variants), incl. arbitrary grid-cols-[a_b]
+    // Tailwind: grid-cols-N (+ responsive variants), incl. arbitrary grid-cols-[a_b].
+    // Arbitrary values use `_` as the space stand-in and may contain functions —
+    // `grid-cols-[repeat(2,_minmax(0,1fr))]` is 2 tracks, not split('_').length=3:
+    // normalize `_`→space and reuse the parens-aware countTracks().
     for (const m of t.matchAll(/(?:^|[\s"'`])(?:(sm|md|lg|xl|2xl):)?grid-cols-(\d+|\[[^\]]+\])/g)) {
-      const cols = m[2].startsWith('[') ? m[2].split('_').length : parseInt(m[2], 10);
+      const cols = m[2].startsWith('[')
+        ? countTracks(m[2].slice(1, -1).replace(/_/g, ' '))
+        : parseInt(m[2], 10);
       sig.grid_cols_max = Math.max(sig.grid_cols_max, cols);
       if (m[1]) {
         sig.has_responsive_prefixes = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baldart",
-  "version": "4.92.0",
+  "version": "4.92.1",
   "description": "Claude Agent Framework - Reusable framework for coordinating AI agents and humans in software projects",
   "bin": {
     "baldart": "./bin/baldart.js"