baldart 5.3.2 → 5.4.1

package/CHANGELOG.md

@@ -5,6 +5,71 @@ 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).
 
+## [5.4.1] - 2026-07-03
+
+**Minimal light lane — the roster for a simple card is now literally: grounding (inline),
+coder, code review, doc review, commit, merge. Nothing else.** Completes v5.4.0 per the
+maintainer's directive ("per cose così semplici voglio due passaggi in croce"): the compact
+lane cut the CARD COUNT; this cuts the per-run AGENT COUNT. FEAT-0067-class run: ~33
+agents → ~7.
+
+- **Per-card doc review at light (single-card batch)**: the light review matrix adds the
+  scoped `doc-reviewer` per-card (review-cycle.md deferral-gate exception) because the
+  Final pass it used to defer to is now skippable.
+- **Final Review skip gate (`final-review.md` § F.0 + `new2.js` `skipFinalLight`)**: ONE
+  light card + zero actionable per-card findings (→ zero fixes applied) → skip F.2–F.5
+  entirely. Honors the v4.56.1 refutation (per-card PRE-fix + final POST-fix are
+  non-redundant) by scoping the skip to runs where there IS no post-fix state; any
+  finding, fix, second card, or degraded reviewer → Final runs as always.
+- **i18n fill spawn cut at light**: the owner briefing instructs the coder to fill every
+  target locale itself; the anti-hardcoded lint + locale-parity gates still enforce.
+- **Production-readiness spawn cut for all-light batches**: no deployable surface exists
+  by Rule C (no migrations/indexes/cron/schema) — the agent only ever reported zero items.
+- `check-new-parity.mjs` rule 18 locks the prose↔workflow lockstep for every cut.
+- Skills: `new` 2.2.0 · `new2` 1.6.0.
+
+Codex parity: portable (prose modules are the cross-tool SSOT; `new2.js` Claude-only by design).
+
+## [5.4.0] - 2026-07-03
+
+**Elastic pipeline — `/prd`+`/new` compress to the minimum for trivial features and
+scale up only on Heavy triggers.** Follow-up of the FEAT-0067 post-mortem: a label
+feature was decomposed into an epic + 2 balanced cards and burned ~54M billed tokens in
+`/new` (+8M in `/prd`) — every child card pays a fixed pipeline cost the feature size
+cannot amortize, and nothing bounded decomposition from below. Both skeptic-refuted and
+adjusted before shipping (epic wrapper kept per HARD RULE 15; PRD compresses PROSE, never
+its section inventory; the grounding obligation is untouched — only its delegation scales).
+
+- **`/prd` Step 2.1 Tier Gate** (skill 1.5.0, `discovery-phase.md`): at Discovery exit
+  the feature is classified TRIVIAL/LIGHT/HEAVY per AGENTS.md § Change Tiers (SSOT,
+  cited not restated) with one user confirm → `lane: compact|full` in the state file.
+  Compact lane: research skipped by default, Step 3 routed toward mockup-only/skipped,
+  compressed-prose PRD (full section structure, 1–2 paragraphs each, ≤3 pages), ONE
+  child card + the mandatory epic tracker, no added audit ceremony (agent depth already
+  scales with `review_profile`). Full lane byte-unchanged.
+- **`prd-card-writer` v1.1.0 — Proportionality lower-bound + Rule C fixes**: atomicity
+  now has a FLOOR (TRIVIAL/LIGHT feature → default ONE child card; split only on an
+  isolable Heavy trigger or different-owner halves each >3 files; sizing rules are upper
+  bounds, never split targets — the tier travels in the Step 5 briefing). Rule C branch
+  (b) gains DS-spec doc-sync transparency (the touched component's spec `.md` counts
+  like a locale file; never for `components_primitives` paths or HEAD-API changes) and a
+  misapplication guard ("tocca i18n / la spec" is never by itself a disqualifier — the
+  exact FEAT-0067-02 misclassification).
+- **AGENTS.md primitive 1.8.0 (+ CLAUDE.md 1.4.3)**: § Change Tiers Heavy trigger
+  refined — an ADDITIVE index-only migration is no longer Heavy by itself (keeps Rule C
+  `db_indexes` depth + the api-perf gate); and a new orchestrated-pipeline exception:
+  inside `/new`/`new2` a `review_profile: light|skip` card satisfies the (unchanged)
+  understanding obligation via the OWNER grounding inline instead of a dedicated
+  `codebase-architect` spawn.
+- **`/new` 2.1.0 light lane (`implement.md` step 2d) + `new2.js` mirror**: light/skip
+  cards skip the Phase-1 retriever spawn; the owner briefing carries the inline-grounding
+  instruction. Guarded by `check-new-parity.mjs` rule 17 (prose + workflow + primitive
+  must stay in lockstep).
+
+Codex parity: portable — the Tier Gate binds `AskUserQuestion` vs plain-prompt via the
+existing `runtime-portability-protocol.md` citation in `/prd`; primitives/AGENTS.md is
+the cross-tool SSOT; `new2.js` stays Claude-only by design (documented gap).
+
 ## [5.3.2] - 2026-07-03
 
 **AGENTS.md primitive 1.7.4 — commit-format MUST scoped to card-bound work.**

package/VERSION

@@ -1 +1 @@
-5.3.2
+5.4.1

package/framework/.claude/agents/CHANGELOG.md

@@ -7,6 +7,18 @@ per-item agent merge, the doctor probes, and the discovery hooks — like
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · per-agent SemVer.
 
+## [prd-card-writer v1.1.0] — 2026-07-03 (framework v5.4.0)
+
+- **Proportionality lower-bound** in Card Atomicity Rules: a Tier-Gate TRIVIAL/LIGHT
+  feature defaults to ONE child card (+ the mandatory epic tracker); splits only on an
+  isolable Heavy trigger or different-owner halves each >3 files. Sizing rules are
+  upper bounds, never split targets. (FEAT-0067: label → epic + 2 balanced cards.)
+- **Rule C branch (b)**: DS-spec doc-sync transparency (the per-component spec .md of a
+  touched component is transparent like locale files — gated on has_design_system, never
+  for components_primitives paths or HEAD-API changes) + misapplication guard ("tocca
+  i18n / la spec" is never by itself a disqualifier — FEAT-0067-02 incident).
+- `version:` frontmatter added.
+
 ## [seo-analytics-strategist v1.1.0] — 2026-07-03 (framework v5.3.0)
 
 - `model: haiku` → `model: sonnet` — haiku is banned fleet-wide (REGISTRY

package/framework/.claude/agents/prd-card-writer.md

@@ -1,5 +1,6 @@
 ---
 name: prd-card-writer
+version: 1.1.0
 description: "Generates atomic backlog cards from an approved PRD. Handles card YAML writing, dependency graph computation, parallel group assignment, and traceability matrices (FR/NFR, ISA, UI). Invoked by the /prd skill at Step 5 to offload the heaviest mechanical phase from the main context. Also runs in Standalone Single-Card Mode to author ONE baseline-conformant follow-up/CHORE/BUG/issue card (no epic+children) — invoked by /new (AC-deferral), new2/new2-resolve, and /issue-review. The canonical card writer: every card-creation path delegates here rather than hand-writing a partial stub."
 model: opus
 effort: high
@@ -252,15 +253,16 @@ Apply the **first matching rule** (priority order — top wins):
 | Profile | When to assign |
 |---------|----------------|
 | **DEEP** | ANY of: `areas` includes both `api` AND `data` — OR title/scope/areas touch `auth`, `payment`, `permission`, `schema`, `migration`, `cron`, `webhook`, `transaction` — OR a path in `files_likely_touched` falls under a `paths.high_risk_modules` entry — OR `data_fields` has ≥3 entries with `status: new` or `status: modified` — OR `db_indexes` present (legacy `firestore_indexes` too) — OR acceptance criteria count > 5 — OR `estimated_complexity: HIGH` — OR API contract changed — OR `> 15` files in `files_likely_touched` (broad blast radius — review every group deeply) |
-| **LIGHT** | EITHER (a) Card is a `bugfix` or `refactor` — AND ≤3 files in `files_likely_touched` — AND none of the DEEP high-risk keywords/areas apply; **OR** (b) **UI-presentational card** — ALL of: the card is pure-UI — `areas` == `[ui]` exactly (no `api`/`data`/`logic`/`auth`), or when `areas` is absent the Rule B signal `owner_agent: ui-expert` stands in for it — AND ≤3 files in `files_likely_touched`, every one a component/style file (no data-fetching, state-management, API-client, or server file) — AND NO path in `files_likely_touched` falls under `paths.components_primitives` (i.e. the card only *composes* existing design-system primitives, it does NOT introduce or modify one) — AND none of the DEEP high-risk keywords/areas apply. **i18n locale-file transparency (when `features.has_i18n: true`):** locale files under `i18n.locales_root` are TRANSPARENT to this branch — exclude them from BOTH the `≤3` count AND the "every file is component/style" test, classifying the card on its NON-locale files only. A label change forces an edit to every locale file (`it.ts`/`en.ts`/…), which would otherwise push a genuinely-presentational card over the file count and inject non-component `.ts` files; but a locale file is a flat string table whose correctness is owned by the i18n gate (anti-hardcoded lint) + `i18n-translator`, NOT the logic cluster — so it must not disqualify the carve-out. Branch (a) is **NEVER for `feature`/`enhancement` cards**; branch (b) is the ONLY route by which a `feature`/`enhancement` card may be `light`. |
+| **LIGHT** | EITHER (a) Card is a `bugfix` or `refactor` — AND ≤3 files in `files_likely_touched` — AND none of the DEEP high-risk keywords/areas apply; **OR** (b) **UI-presentational card** — ALL of: the card is pure-UI — `areas` == `[ui]` exactly (no `api`/`data`/`logic`/`auth`), or when `areas` is absent the Rule B signal `owner_agent: ui-expert` stands in for it — AND ≤3 files in `files_likely_touched`, every one a component/style file (no data-fetching, state-management, API-client, or server file) — AND NO path in `files_likely_touched` falls under `paths.components_primitives` (i.e. the card only *composes* existing design-system primitives, it does NOT introduce or modify one) — AND none of the DEEP high-risk keywords/areas apply. **i18n locale-file transparency (when `features.has_i18n: true`):** locale files under `i18n.locales_root` are TRANSPARENT to this branch — exclude them from BOTH the `≤3` count AND the "every file is component/style" test, classifying the card on its NON-locale files only. A label change forces an edit to every locale file (`it.ts`/`en.ts`/…), which would otherwise push a genuinely-presentational card over the file count and inject non-component `.ts` files; but a locale file is a flat string table whose correctness is owned by the i18n gate (anti-hardcoded lint) + `i18n-translator`, NOT the logic cluster — so it must not disqualify the carve-out. **DS-spec doc-sync transparency (v5.4.0, when `features.has_design_system: true`):** the per-component spec `.md` of a component file ALREADY in the card's file set is TRANSPARENT the same way — it is the mandatory `DS_COMPONENT_STALE` doc-sync artifact of touching that component (owned by `doc-reviewer` + the Post-Intervention Coherence gate), not logic. This transparency applies ONLY when the spec edit is doc-sync (documenting the presentational change — NO `variant_prop`/HEAD-API change) and NEVER makes a `paths.components_primitives` path transparent (that DEEP signal stands). **Misapplication guard (FEAT-0067-02 incident):** "tocca i18n" / "tocca la spec" are NEVER by themselves reasons to disqualify branch (b) — apply the transparencies FIRST, then classify on the residual file set. Branch (a) is **NEVER for `feature`/`enhancement` cards**; branch (b) is the ONLY route by which a `feature`/`enhancement` card may be `light`. |
 | **SKIP** | Card is `docs`, `chore`, or `config` — OR all `files_likely_touched` are `.md`/non-API `.yml`/CSS with zero logic files (**when `features.has_i18n: true`, locale files under `i18n.locales_root` are EXCLUDED from this set the same way they are for the LIGHT branch — a pure-cosmetic CSS/copy fix that also retouches locale strings stays `skip`; classify on the non-locale files only**) — OR a pure-cosmetic card (typo/rename/copy/wording/style) with no code areas |
 | **BALANCED** | Default for everything else — ALL `feature`/`enhancement` cards not matching DEEP, plus any `bugfix`/`refactor` with >3 files or breadth that isn't DEEP |
 
 **Critical**: `feature` and `enhancement` cards are `balanced` minimum — **with exactly one
 exception**: the LIGHT branch (b) above, a strictly UI-presentational card (`areas == [ui]`,
-≤3 component/style files — locale files under `i18n.locales_root` excluded from the count when
-`features.has_i18n: true`, see the LIGHT row — composes existing primitives without touching any
-`paths.components_primitives` path). This narrow carve-out targets the `-ui` half of a
+≤3 component/style files — locale files under `i18n.locales_root` (when
+`features.has_i18n: true`) and DS-spec doc-sync `.md` files of touched components (when
+`features.has_design_system: true`) excluded from the count, see the LIGHT row — composes
+existing primitives without touching any `paths.components_primitives` path). This narrow carve-out targets the `-ui` half of a
 logic/ui split pair (e.g. a `…-submit-ui` card whose logic lives in its `…-submit-logic`
 sibling): reviewing a pixels-only diff at Codex-`full` depth is waste, and the design-system
 safety net still fires regardless of profile (a `light` card keeps its per-card code-review —
@@ -285,10 +287,23 @@ only compute when the field is empty.
 
 Cards MUST be as atomic as possible to enable parallel execution:
 
+**Proportionality lower-bound (v5.4.0 — atomicity has a FLOOR, not just a ceiling):**
+every child card carries a fixed pipeline cost in `/new` (grounding + owner + reviews +
+doc + QA + commit) regardless of its size, so splitting a small feature multiplies cost
+without adding safety. When the `/prd` Tier Gate classified the feature **Trivial or
+Light** (AGENTS.md § Change Tiers — passed down by the skill): default to **ONE child
+card** (the epic wrapper stays, per Card Structure below — it is a zero-cost tracker).
+Split a Light feature ONLY when (a) a Heavy trigger applies to an isolable sub-part, or
+(b) the halves have DIFFERENT `owner_agent` AND each half touches **>3 files** on its own
+(real parallelism, not ceremony). A logic+UI pair below that threshold stays ONE mixed
+card (`owner_agent` per Rule B; `review_profile` per Rule C — a mixed feature card is
+`balanced`, which is still one pipeline instead of two). The sizing rules below are
+**upper bounds that trigger splits, never targets to split toward**.
+
 **Sizing rules:**
 - Each card SHOULD touch at most 8 files. If more, split into sub-cards.
 - Each card SHOULD have at most 5 acceptance criteria. If more, split by concern.
-- If a card has both API + UI work, consider splitting into API card + UI card (unless tightly coupled and sharing <3 files).
+- If a card has both API + UI work, consider splitting into API card + UI card (unless tightly coupled and sharing <3 files, or the feature is Light-tier — see the lower-bound above).
 
 **Splitting heuristics:**
 - Split by concern: data model vs API vs UI vs docs

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

@@ -2,6 +2,25 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 2.2.0 — 2026-07-03 (framework v5.4.1)
+
+- **Minimal light lane — roster cut to the core four.** A single light card now runs:
+  grounding-inline (step 2d) → owner → code review (Codex-light/code-reviewer) → scoped
+  doc-reviewer per-card (review-cycle deferral exception) → commit → merge. Cut for the
+  lane: i18n fill spawn (7c — owner fills locales inline, lint gate enforces), Final
+  Review when the per-card review is clean (final-review.md § F.0 Minimal-light skip
+  gate — POST-fix verification with zero fixes is vacuous; any finding/fix/second card →
+  Final runs), production-readiness spawn for all-light batches (no deployable surface
+  by Rule C). Guarded by check-new-parity rule 18.
+
+## 2.1.0 — 2026-07-03 (framework v5.4.0)
+
+- **Light-lane inline grounding (implement.md step 2d).** A `review_profile: light` card
+  skips the dedicated codebase-architect spawn (steps 3–4); the OWNER grounds inline per
+  AGENTS.md § Change Tiers orchestrated-pipeline exception. Obligation unchanged,
+  delegation waived at ≤3-file scale. new2.js mirrors (`inline-light` lane); guarded by
+  check-new-parity rule 17.
+
 ## 2.0.1 — 2026-07-03
 
 Adversarial-verification fixes on the v5.0.0 pipeline wave (framework v5.0.1):

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

@@ -1,7 +1,7 @@
 ---
 name: new
 effort: medium
-version: 2.0.1
+version: 2.2.0
 description: >
   Orchestrate a team of specialized agents to implement one or more backlog cards
   end-to-end inside a dedicated worktree, with code review, doc review, QA, and

package/framework/.claude/skills/new/references/final-review.md

@@ -42,6 +42,19 @@ Once ALL cards are committed in the worktree:
 > A single card has no cross-card surface, so a finder's per-card pass and its final pass are genuinely
 > the same review.
 
+### Step F.0 — Minimal-light skip gate (v5.4.1)
+
+When the batch has exactly ONE committed card AND it is `review_profile: light` AND its
+per-card review surfaced ZERO actionable findings (no blocks, no scope-expansion → no fix
+pass was applied), **SKIP the entire Final Review** (F.2–F.5) and proceed to merge. The
+Final pass exists for POST-fix verification and cross-card surface (v4.56.1 — per-card
+PRE-fix + final POST-fix are non-redundant); with zero fixes and zero cross-card surface,
+both reasons are absent — and doc coverage already ran per-card (the single-card light
+review matrix includes the scoped doc-reviewer instead of deferring here, see
+review-cycle.md § Deferral gate). Any finding on the card, any fix applied, any second
+card, or any degraded reviewer → run the Final Review as written below. Log
+`final-review: SKIPPED (single light card, clean per-card review — nothing post-fix to verify)`.
+
 ### Step F.1 — Resolve scope
 
 (All cards are committed; the batch now enters Final Review. No visibility emission — the internal tracker is the only state surface, see SKILL.md § "State surface — the tracker only". Record the Final-Review start/finish in the tracker only.)

package/framework/.claude/skills/new/references/implement.md

@@ -10,7 +10,8 @@
    - If `DONE` (or the user chose "proceed anyway") → continue.
 2b. **Claim** — only now set the card status to `IN_PROGRESS` (in the backlog YAML / tracker) and assign yourself. This is a state write, not a visibility emission — do not also spend a TaskUpdate / Progress-Bar turn (§ "State surface — the tracker only").
 2c. **Trivial-card classification (BLOCKING gate for steps 3–4)** — evaluate `IS_TRIVIAL(card)` per § "Trivial-card fast-lane". Note: condition 3 (non-source diff) cannot be fully evaluated until the coder has produced the diff, so at this point compute the **provisional** trivial flag from conditions 1+2 only (`review_profile == skip` AND no Step-A trigger sourced from the card YAML text + `files_likely_touched` extensions — if EVERY path in `files_likely_touched` is non-source, condition 3 is provisionally satisfied). If provisionally trivial → **SKIP steps 3, 3a, and 4** (architecture grounding); log `trivial: architecture grounding skipped (review_profile=skip + non-source files_likely_touched + 0 triggers)` and jump to Phase 2. Re-confirm `IS_TRIVIAL` on the ACTUAL committed diff at the review gates (Phase 2.55/3.5/3.7); if the coder unexpectedly touched a source file, the guard flips the card back onto the normal review path there. If NOT provisionally trivial → run steps 3, 3a, 4 as normal.
-3. **(skip when provisionally trivial — see 2c)** Invoke the **codebase-architect** agent (MUST per AGENTS.md) to understand the relevant codebase area, existing patterns, and architecture before any implementation. When `features.has_lsp_layer: true`, the architect uses LSP find-references for identifier-shaped lookups — this needs NO handoff from the orchestrator: the architect reads `features.has_lsp_layer` from `baldart.config.yml` directly (the flag is ambient) per `agents/code-search-protocol.md`. Likewise, when `features.has_code_graph: true`, the architect uses the Graphify code graph for structural/relational lookups (ambient flag) per `agents/code-graph-protocol.md`. The orchestrator does NOT propagate either flag. (Earlier doc versions numbered this step 4; the step that read project-status BEFORE the architect was removed because it persisted pre-analysis context — see step 3a.) **Pass `OUTPUT=terse` in the architect prompt (since v4.49.0)** — this is grounding for the coder/reviewer, not an explanation, so the architect returns its structured contract (reuse table + canonical evidence + `path:line — symbol` rows + `totals:`) without narrative prose. **Pass the analysis profile too (since v4.94.0)**: `PROFILE=ui` when the card has a non-empty `links.design` OR `links.design_src` (the same mockup bit that drives step 6a), else `PROFILE=feature` — contract and per-profile scoping in `agents/analysis-profiles.md` (its § 3 caller routing table is normative). The profile is deterministic from the card YAML; never leave the architect to infer it. The verbatim baseline persisted at step 5b keeps all the substance a lean `/codexreview` needs (paths, signatures, patterns, high-risk paths) while staying small in the orchestrator's context and on disk. **Baseline content contract (MANDATORY — since v4.56.0):** the architect prompt is grounding INPUT only — pass the card scope, `files_likely_touched`, and the question to map. NEVER put line-level fix directives ("remove lines 90-91", "Fix: use X"), the words "implement/fix/apply", or acceptance-criteria framed as a task into the architect prompt. The architect produces a read-only MAP (file/symbol locations, patterns, type signatures, integration points, high-risk paths); it does NOT implement and has no `Task`/Agent tool to delegate (see `codebase-architect.md` § Role boundary). The coder is a separate spawn the orchestrator owns.
+2d. **Light-lane inline grounding (since v5.4.0 — BLOCKING gate for steps 3–4, after 2c)** — when the card is NOT provisionally trivial AND `review_profile == light`: **SKIP step 3 (the dedicated codebase-architect spawn) and step 4** — the OWNER agent grounds INLINE instead, per **AGENTS.md § Change Tiers, orchestrated-pipeline exception** (a light card is ≤3 files with no logic-risk signal by Rule C; a dedicated retriever at that scale costs more than the exploration it isolates). The understanding obligation is UNCHANGED — only the delegation is waived: the owner briefing (step 6/7) MUST carry the line "Ground INLINE before coding: read the files in scope + their immediate integration points; scoped exploration only". Step 3a still runs (write Active Code Context from the card YAML, noting `grounding: inline-light`). Log `phase1: INLINE-LIGHT (review_profile=light — no retriever spawn, owner grounds inline)`. `balanced`/`deep` cards run steps 3, 3a, 4 as written — this lane never applies to them.
+3. **(skip when provisionally trivial — see 2c — or on the light lane — see 2d)** Invoke the **codebase-architect** agent (MUST per AGENTS.md) to understand the relevant codebase area, existing patterns, and architecture before any implementation. When `features.has_lsp_layer: true`, the architect uses LSP find-references for identifier-shaped lookups — this needs NO handoff from the orchestrator: the architect reads `features.has_lsp_layer` from `baldart.config.yml` directly (the flag is ambient) per `agents/code-search-protocol.md`. Likewise, when `features.has_code_graph: true`, the architect uses the Graphify code graph for structural/relational lookups (ambient flag) per `agents/code-graph-protocol.md`. The orchestrator does NOT propagate either flag. (Earlier doc versions numbered this step 4; the step that read project-status BEFORE the architect was removed because it persisted pre-analysis context — see step 3a.) **Pass `OUTPUT=terse` in the architect prompt (since v4.49.0)** — this is grounding for the coder/reviewer, not an explanation, so the architect returns its structured contract (reuse table + canonical evidence + `path:line — symbol` rows + `totals:`) without narrative prose. **Pass the analysis profile too (since v4.94.0)**: `PROFILE=ui` when the card has a non-empty `links.design` OR `links.design_src` (the same mockup bit that drives step 6a), else `PROFILE=feature` — contract and per-profile scoping in `agents/analysis-profiles.md` (its § 3 caller routing table is normative). The profile is deterministic from the card YAML; never leave the architect to infer it. The verbatim baseline persisted at step 5b keeps all the substance a lean `/codexreview` needs (paths, signatures, patterns, high-risk paths) while staying small in the orchestrator's context and on disk. **Baseline content contract (MANDATORY — since v4.56.0):** the architect prompt is grounding INPUT only — pass the card scope, `files_likely_touched`, and the question to map. NEVER put line-level fix directives ("remove lines 90-91", "Fix: use X"), the words "implement/fix/apply", or acceptance-criteria framed as a task into the architect prompt. The architect produces a read-only MAP (file/symbol locations, patterns, type signatures, integration points, high-risk paths); it does NOT implement and has no `Task`/Agent tool to delegate (see `codebase-architect.md` § Role boundary). The coder is a separate spawn the orchestrator owns.
 3a. Update `${paths.references_dir}/project-status.md` Active Code Context (skip when the file does not exist in the project) — do this AFTER the codebase-architect run (step 3) so the "Active Code Context" reflects the architect's findings (which files are actually in scope), not just the card YAML's `files_likely_touched`. Writing it before the architect run would persist pre-analysis claims that downstream agents (e.g. a parallel card) would then read as truth.
 4. **Plan-auditor grounding check** — but first, a **provenance skip (since v4.7.0 — mirror of Step 3d)**: the `/prd` Step 6.6 holistic audit already ran a per-card grounding pass when the card was authored. Re-grounding here is only worth a plan-auditor spawn if something changed since. **This skip is the NORMAL path for a card implemented right after `/prd`, not an occasional optimization** — `/prd` now guarantees the `metadata.holistic_audit` stamp lands on every audited card (deterministic backstop at `validation-phase.md` Step 7 item 5b, since the v4.88.2 provenance-reliability fix), so P1 below holds whenever the batch is freshly authored. Skip the plan-auditor when **BOTH** hold:
    - **P1 — provenance present**: the card has `metadata.holistic_audit` with non-empty `audited_at`, `audited_commit`, `audited_set`.
@@ -499,7 +500,7 @@
    - **Grounding (cheap `grep`, like the Phase-1 plan-auditor grounding):** every cited source symbol/class MUST appear in `mockups/_src/` (`grep -rF "<symbol>" <prd_dir>/<slug>/mockups/_src/`), and every cited registry primitive MUST exist in the registry (`grep` `${paths.design_system}/INDEX.md` / `components/`). A symbol that is not in the source, or a primitive that is not in the registry, means a fabricated declaration → reject + re-spawn (do NOT pass it to the gates). Log `design-source: grounded` or `design-source: rejected (<reason>)` in the tracker.
    - This does NOT re-verify pixels — that stays with `visual-fidelity-verifier` (Phase 2.6). It only proves the source was read and the reuse-mapping targets are real. When the card has no design source, skip this step entirely.
 
-7c. **i18n fill pass (explicit, deterministic — v5.0.0, promoted from the step-9 sub-bullet).** When `features.has_i18n: true` AND this card's diff added new source-locale keys — detect deterministically, never by intuition:
+7c. **i18n fill pass (explicit, deterministic — v5.0.0, promoted from the step-9 sub-bullet).** **Light lane (v5.4.1): SKIP this spawn** — on the light lane (step 2d) the owner briefing already instructed the coder to fill EVERY target locale itself (context-aware from the registry); the anti-hardcoded lint + locale-parity gates at step 8 enforce it. Log `i18n-fill: SKIP (light lane — owner fills inline)`. Otherwise: when `features.has_i18n: true` AND this card's diff added new source-locale keys — detect deterministically, never by intuition:
    ```bash
    cd <worktree-path>
    # $SRC_LOCALE = the source-language locale file path (from i18n config / the project's locales root)

package/framework/.claude/skills/new/references/production-readiness.md

@@ -6,6 +6,12 @@
 
 After Phase 6 completes (or after the final summary report if Phase 6 is deferred), present a **Production Readiness Checklist** — a clear list of all manual or infrastructure actions required to launch the implemented changes in production.
 
+> **Minimal light lane (v5.4.1): SKIP the spawn for an all-`light` batch** — a light card
+> carries no deployable surface by Rule C (no migrations, indexes, cron, schema, env); the
+> checklist agent would only report zero items. Log
+> `phase7-production: SKIPPED (all-light batch — no deployable surface)`. Any
+> `balanced`/`deep` card in the batch → run as written.
+
 ### How to detect items
 
 Scan ALL files changed across the batch (use the tracker's completed cards + `git diff` against the base branch) and check for the items below.

package/framework/.claude/skills/new/references/review-cycle.md

@@ -305,7 +305,7 @@ skill's Phase 1 falls back to deriving Gherkin scenarios from
 
 > **Note**: Code review is NOT performed in this phase — it is handled by the **mandatory unconditional `/codexreview` gate in Phase 3.7**, which runs per-card BEFORE the Phase 4 commit. The post-batch `/codexreview` in the Final review remains as a final FULL-diff sweep over the entire batch (since v3.37.0 — the guaranteed full-depth merge gate). This Phase 3 focuses exclusively on documentation sync, which must happen per-card (tied to the specific commit).
 
-> **Deferral gate (since v4.7.0 — enumerated, `review_profile`-driven)**: SKIP per-card doc-review and defer it to the **Final Review F.3 doc-reviewer** (which runs over the entire batch) when the card is **`review_profile == light` AND its committed diff touches NO documentation file** (no `.md`, no path under `${paths.references_dir}`, no data-model/ssot/api doc). These are small code changes with no doc surface of their own; their only doc concern is drift, which the batch-wide Final doc-reviewer catches. Log `doc-review: DEFERRED to Final FULL gate (light, no doc files in diff)` and proceed to Phase 3.5. **KEEP per-card doc-review** for: `deep` cards, `balanced` cards (they may still PASS-fast via the deterministic gate below — that gate, not this deferral, is their only skip lane), ANY card whose diff touches a doc file (the change IS doc-relevant), and trivial cards (doc-review is their primary gate — § "Trivial-card fast-lane", unchanged). Never defer "for time" — the only enumerated reasons are `light + non-doc diff` and the deterministic PASS-fast below.
+> **Deferral gate (since v4.7.0 — enumerated, `review_profile`-driven)**: SKIP per-card doc-review and defer it to the **Final Review F.3 doc-reviewer** (which runs over the entire batch) when the card is **`review_profile == light` AND its committed diff touches NO documentation file** (no `.md`, no path under `${paths.references_dir}`, no data-model/ssot/api doc). These are small code changes with no doc surface of their own; their only doc concern is drift, which the batch-wide Final doc-reviewer catches. Log `doc-review: DEFERRED to Final FULL gate (light, no doc files in diff)` and proceed to Phase 3.5. **KEEP per-card doc-review** for: `deep` cards, `balanced` cards (they may still PASS-fast via the deterministic gate below — that gate, not this deferral, is their only skip lane), ANY card whose diff touches a doc file (the change IS doc-relevant), and trivial cards (doc-review is their primary gate — § "Trivial-card fast-lane", unchanged). Never defer "for time" — the only enumerated reasons are `light + non-doc diff` and the deterministic PASS-fast below. **Single-card light batch exception (v5.4.1 minimal light lane): do NOT defer** — when the batch has exactly ONE card and it is `light`, the Final Review is itself SKIPPED if the per-card review is clean (see final-review.md § Minimal-light skip gate), so the deferral target would never run: run the scoped per-card doc-reviewer here instead.
 >
 > **Deterministic PASS-fast (v5.0.0 — measured: 84/127 per-card doc reviews returned PASS)**: when implement.md step 11c produced `/tmp/docinv-<CARD-ID>.json` AND it says `pass_fast_eligible: true` (zero non-advisory invariant rows triggered + no doc file in the diff + the card declares no `documentation_impact`/`canonical_docs`) AND the card is NOT `deep` → log `doc-review: PASS-fast (doc-invariants: 0 blocking rows) — Final doc-reviewer backstop stands` and **skip the per-card spawn** (proceed to Phase 3.5). No gate is removed: the batch-Final F.3 doc-reviewer still sees this card's diff. Own-Doc Closure: NEW-file obligations are definitionally empty (no invariant row fired, no docs declared); obligations on MODIFIED primitives/routes are covered by the automatic spec resync (`DS_COMPONENT_STALE` serializer gate, v4.70.0) plus the Final F.3 backstop — the invariant table's R1/R3 fire on new files only, by design. `deep` cards always spawn. Missing docinv JSON → no PASS-fast (fall through to the normal path).
 

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

@@ -2,6 +2,20 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## (workflow new2.js, framework v5.4.1) — 2026-07-03
+
+- Minimal light lane mirror: single-card light adds per-card doc-reviewer to the review
+  matrix, skips the i18n fill spawn (owner briefing carries the fill instruction),
+  skips new-final-review when `lightLane && cleanReview` (zero actionable findings),
+  skips production-readiness for all-light batches. Result objects carry
+  `lightLane`/`cleanReview` for the Final gate.
+
+## (workflow new2.js, framework v5.4.0) — 2026-07-03
+
+- Light lane: `review_profile: light|skip` cards no longer spawn the Phase-1 retriever —
+  the owner briefing carries the inline-grounding instruction instead (implement.md
+  step 2d is the prose SSOT). Mirrors /new 2.1.0.
+
 ## 1.4.1 — 2026-07-03
 
 - **Multi-card diff scoping (framework v5.0.1)**: the implement brief now instructs the coder

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

@@ -1,7 +1,7 @@
 ---
 name: new2
 effort: high
-version: 1.4.1
+version: 1.6.0
 description: >
   Workflow-hosted batch engine for /new. Implements one or
   more backlog cards end-to-end by delegating the WHOLE batch to a background

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

@@ -2,6 +2,17 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.5.0 — 2026-07-03 (framework v5.4.0)
+
+- **Step 2.1 Tier Gate (elastic pipeline).** At Discovery exit the feature is classified
+  TRIVIAL/LIGHT/HEAVY per AGENTS.md § Change Tiers (SSOT), one user confirm, `lane:
+  compact|full` recorded in the state file. Compact lane: research skipped by default,
+  Step 3 routed toward mockup-only/skipped, PRD compressed-prose (FULL section structure,
+  1-2 paragraphs each, ≤3 pages), ONE child card + mandatory epic (prd-card-writer
+  Proportionality lower-bound; tier passed in the Step 5 briefing), no extra audit
+  ceremony (agent depth already scales with review_profile). Full lane unchanged.
+  Driven by the FEAT-0067 post-mortem (label feature → epic + 2 balanced cards → ~54M).
+
 ## 1.4.0 — 2026-07-03
 
 - **Research-profile contract + library (framework v5.1.0)**: Step 2.5 now

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

@@ -1,7 +1,7 @@
 ---
 name: prd
 effort: high
-version: 1.4.0
+version: 1.5.0
 description: "Structured PRD creation skill. Use when the user says /prd, 'crea un prd', 'nuova funzionalita', 'pianifica feature', or wants to plan a new feature end-to-end. Also handles /prd-add, 'aggiungi requisito', 'serve anche', 'manca un endpoint' for change requests on active PRD sessions — runs ICIAS impact analysis to determine which phases need SKIP/PATCH/REDO. Produces PRD + UI design + backlog cards, all validated and committed. Multi-turn conversation: asks questions, waits for answers, iterates through discovery, design, spec writing, card creation, and validation phases."
 ---
 
@@ -42,6 +42,7 @@ message. You ask questions, wait for answers, and iterate.
 | 1.2 | Obsidian provisional back-reference (only if a spec note was given) | [discovery-phase.md](references/discovery-phase.md) + [obsidian-backref.md](references/obsidian-backref.md) |
 | 1.6 | Mockup Intake | [discovery-phase.md](references/discovery-phase.md) |
 | 2 | Discovery Question Loop (+ Codex completeness cross-check at exit, v4.19.0) | [discovery-phase.md](references/discovery-phase.md) |
+| 2.1 | Tier Gate — classify TRIVIAL/LIGHT/HEAVY per AGENTS.md § Change Tiers, route `lane: compact\|full` (compact = compressed PRD, 1 child card, research/mockup skipped by default) | [discovery-phase.md](references/discovery-phase.md) § Step 2.1 |
 | 2→CR | Change Request (auto/manual) | the canonical **`prd-add` skill** ([../prd-add/SKILL.md](../prd-add/SKILL.md)) — worktree-aware (`references/prd-add-phase.md` is a redirect stub, not the implementation) |
 | 2.5 | Research (opzionale) | [research-phase.md](references/research-phase.md) |
 | 3 | UI Design (3a-3d) | [ui-design-phase.md](references/ui-design-phase.md) |

package/framework/.claude/skills/prd/references/backlog-phase.md

@@ -202,6 +202,10 @@ Agent(
     (The /prd run's session UUID — set provenance.planning_session on every card.
     See your "Session provenance" section. Omit the field if this value is empty.)
 
+    TIER: <tier from the state file ## Tier section — TRIVIAL|LIGHT|HEAVY>
+    (Step 2.1 Tier Gate result. TRIVIAL/LIGHT → apply your "Proportionality
+    lower-bound": default ONE child card + the epic; split only per its criteria.)
+
     PRD path: <$WORKTREE_PATH>/<prd_path>
     State file path: <$WORKTREE_PATH>/<state_file_path>
     Card template: <$WORKTREE_PATH>/.claude/skills/prd/assets/card-template.yml

package/framework/.claude/skills/prd/references/discovery-phase.md

@@ -1093,8 +1093,8 @@ End with: 'COMPLETE — no material gaps' if the discovery is genuinely sufficie
   - **After processing (whatever the outcome), write ONE `discovery-completeness:` entry to the Discovery Log** (e.g. `discovery-completeness: 2 gaps asked, 1 skipped` / `COMPLETE — no material gaps`). This entry is the once-per-session guard above — its presence means the sweep has run and MUST NOT run again this session.
 - **Fallback (Codex unavailable — `$CHECK_FILE` empty, contains `CODEX_NOT_FOUND`, or holds no parseable findings)**: **skip the cross-check** and log `discovery-completeness: SKIPPED (Codex unavailable)` in the Discovery Log (this also satisfies the once-per-session guard). This gate is **additive** — the 99% formula + mockup + research gates already gate exit. Do NOT fall back to a same-model Claude pass: the entire value here is cross-model diversity, and Claude just conducted the interview (it carries the very blind spot this check exists to catch), so a Claude self-review adds little and is not worth the spawn. Proceed to exit.
 
-When loop exits: mark task 1 as `completed`. Update state file status to
-`ui-design` (or `specs-confirmed` if UI is N/A).
+When loop exits: mark task 1 as `completed`. Run **Step 2.1 — Tier Gate** (below),
+then update state file status to `ui-design` (or `specs-confirmed` if UI is N/A).
 
 **Output:**
 
@@ -1103,6 +1103,7 @@ Discovery completata! Tutte le dimensioni sono coperte.
 
 [Brief summary of key decisions made]
 [If research: brief summary of key findings]
+Tier: <TRIVIAL|LIGHT|HEAVY> → lane <compact|full>
 
 Passo alla fase successiva: [UI Design / Scrittura PRD]
 
@@ -1111,6 +1112,43 @@ Passo alla fase successiva: [UI Design / Scrittura PRD]
 
 ---
 
+## Step 2.1 — Tier Gate (proportionality — the pipeline scales with the feature)
+
+**Purpose**: the `/prd`→`/new` pipeline must scale UP for complex features and COMPRESS
+to the minimum for trivial ones — every child card and every full-ceremony phase has a
+fixed cost that a small feature cannot amortize (FEAT-0067: a label feature decomposed
+into 2 balanced cards burned ~54M tokens; as 1 card on the compact lane it costs a
+fraction). This gate runs ONCE, at Discovery exit, and routes every later phase.
+
+1. **Classify** the whole feature by Change Tier per the installed **`AGENTS.md`
+   § Change Tiers** (the SSOT — do NOT restate its triggers here; read that section).
+   Discovery has already surfaced the classification inputs (data model deltas, new
+   routes/entities, dependencies, refactor breadth). Note the v5.4.0 refinement: an
+   ADDITIVE index-only migration does NOT make the feature Heavy by itself.
+2. **Confirm with the user** — ONE question, then proceed (Claude Code:
+   `AskUserQuestion` with the computed tier as the recommended option; Codex: plain
+   prompt — `agents/runtime-portability-protocol.md` § decision gate):
+   "Tier `<computed>` → lane `<compact|full>`. Confermi?" Honor an override silently.
+3. **Record** `tier:` and `lane:` in the state file (`## Tier` section). `TRIVIAL`/
+   `LIGHT` → `lane: compact`; `HEAVY` → `lane: full`.
+
+**Compact lane consequences** (each phase keeps its own doc as SSOT — this list only
+routes; `lane: full` changes NOTHING):
+
+| Phase | Compact-lane behavior |
+|-------|----------------------|
+| 2.5 Research | Skipped by default (run only on explicit user request) |
+| 3 UI Design | Route through the EXISTING Step 3 decision tree toward `mockup-only`/`skipped`: no new-screen mockup generation for tweaks on existing screens |
+| 4 PRD | **Compressed prose, full structure**: keep ALL mandatory sections, write each in 1–2 paragraphs, drop genuinely-N/A sections per the existing rule (target ≤3 pages). NEVER skip ISA/Schema-Verification — downstream consumers read them |
+| 4.5 API-perf gate | Unchanged (already conditional on api/data surface) |
+| 5 Cards | **ONE child card + the mandatory epic** (HARD RULE 15 stands — the epic is a zero-cost tracker). The `prd-card-writer` § Proportionality lower-bound governs; pass the tier to the agent in its briefing |
+| 6 Audit | Deterministic validation (0-i, 0-ii, field-name) ALWAYS runs; agent-depth audits scale with `review_profile` as they already do — no extra teammate panel for a single light/balanced card |
+
+The tier ALSO travels to the cards: `prd-card-writer` receives `tier: <value>` in its
+briefing and applies the Proportionality lower-bound + Rule C accordingly.
+
+---
+
 ## Appendix — Mockup analysis schema
 
 Used by Step 1.6.5. Populate the `## UI Design` section of the state file with this

package/framework/.claude/skills/prd/references/prd-writing-phase.md

@@ -105,7 +105,14 @@ Mark task 3 as `in_progress`.
 
 ### PRD sections checklist
 
-Every PRD MUST include these sections (remove only when genuinely N/A):
+Every PRD MUST include these sections (remove only when genuinely N/A).
+**Compact lane (`lane: compact` from Step 2.1 Tier Gate)**: the STRUCTURE is unchanged —
+keep every applicable section (downstream consumers read them: `prd-card-writer` Field
+Grounding reads § Schema Verification, the backlog phase reads § 15 ISA, the Step 6 audit
+reads the whole document) — but write each section in **1–2 paragraphs**, collapse related
+sections' prose (Personas + User stories may share one compact narrative), and drop
+genuinely-N/A sections per the existing rule. Target ≤3 pages. Compression is in the
+PROSE, never in the section inventory:
 
 - Problem statement
 - Strategic rationale (Section 1b — from `## Business Rationale` in state file)

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

@@ -554,7 +554,15 @@ async function runCard(cardId, cardPath) {
   const baselinePath = `/tmp/arch-baseline-${cardId}.md`
   const phase1 = { architect: 'inline-fallback', audit: 'skipped-no-drift' }
   let arch = null
-  try {
+  // v5.4.0 light lane — a light/skip card (Rule C: ≤3 files, no logic-risk signal) grounds
+  // INLINE via its owner instead of a dedicated retriever spawn (AGENTS.md § Change Tiers,
+  // orchestrated-pipeline exception): at that scale the spawn costs more than the exploration
+  // it isolates (FEAT-0067: ~1.0-1.5M per retriever + schema retries). balanced/deep keep it.
+  const lightLane = reviewProfile === 'light' || reviewProfile === 'skip'
+  if (lightLane) {
+    phase1.architect = 'inline-light'
+    g('phase1-architect', 'INLINE-LIGHT', `review_profile=${reviewProfile} — no dedicated retriever; owner grounds inline (AGENTS.md § Change Tiers exception)`)
+  } else try {
     arch = await agentSafe(
       `You are the Phase-1 context retriever for card ${cardId} (per ${REF}/implement.md Phase 1 step 3 / 5b). cd into the worktree ${sharedCtx.worktreePath}.\n\n` +
         // Analysis profile (v4.94.0 — implement.md step 3 parallel): deterministic from the
@@ -608,7 +616,9 @@ async function runCard(cardId, cardPath) {
   // --- Phase 2: dispatch the card's OWNER_AGENT (F-024), not general-purpose. ---
   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.`
+    : phase1.architect === 'inline-light'
+      ? `Phase 1 light lane (v5.4.0): this card is review_profile '${reviewProfile}' (≤3-file scale) — no dedicated retriever ran. Ground INLINE per AGENTS.md § Change Tiers (orchestrated-pipeline exception): BEFORE writing code, read the files in scope + their immediate integration points (imports/consumers). Scoped exploration of the touched area only — not a repo sweep; the understanding obligation is unchanged, only the delegation was waived.${features.has_i18n ? ' I18N (light lane): NO separate fill pass runs for this card — fill EVERY target locale yourself for any new key (context-aware from the registry); the anti-hardcoded lint gate must pass.' : ''}`
+      : `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
@@ -660,7 +670,10 @@ async function runCard(cardId, cardPath) {
   // v5.0.0 — explicit i18n fill pass (implement.md step 7c mirror; closes the measured leakage
   // where locale fills were spawned as general-purpose). The translator is named BY TYPE; it
   // self-detects new source-locale keys from the diff and no-ops cheaply when there are none.
-  if (features.has_i18n) {
+  // v5.4.1 minimal light lane — no separate fill pass: the owner filled every locale itself
+  // (its briefing carries the instruction) and the Phase-2 anti-hardcoded lint gate enforces it.
+  if (features.has_i18n && lightLane) g('i18n-fill', 'SKIP', 'light lane — owner fills locales inline; lint gate enforces')
+  else if (features.has_i18n) {
     try {
       const fill = await agentSafe(
         `You are i18n-translator (fill pass for card ${cardId} — agents/i18n-protocol.md per-card cascade). cd into the card worktree. FIRST detect deterministically whether this card's diff (/tmp/diff-${cardId}.txt) added NEW source-locale keys; if none → return { ran:false, keys:0 } immediately (no-op). If keys exist: fill the missing TARGET locales for exactly those keys, context-aware from the registry at ${paths.i18n_registry || 'the i18n registry'} — the source locale stays untouched (the coder is source-only by design). Then re-run the project's locale-parity check if one exists. Return: { ran, keys, note }`,
@@ -824,7 +837,14 @@ async function runCard(cardId, cardPath) {
   }
   let reviewers
   if (reviewProfile === 'skip') reviewers = []
-  else if (reviewProfile === 'light') reviewers = codexAvail ? ['codex'] : ['code-reviewer']
+  else if (reviewProfile === 'light') {
+    reviewers = codexAvail ? ['codex'] : ['code-reviewer']
+    // v5.4.1 minimal light lane — a single-card light batch skips the Final workflow when its
+    // per-card review is clean (nothing post-fix to verify), so doc coverage cannot defer
+    // there: run the scoped doc-reviewer per-card instead. Multi-card light keeps the
+    // deferral (the Final batch pass still runs and covers it).
+    if (cardIds.length === 1) reviewers.push('doc-reviewer')
+  }
   else if (noEvidence) reviewers = FULL_FANOUT // balanced/deep, no surface evidence → conservative full
   else reviewers = relevanceGated() // balanced AND deep — surface-gated breadth
   if (reviewProfile !== 'skip') g('review-matrix', 'PLANNED', `[${reviewProfile}${noEvidence ? '→conservative-full (no surface evidence)' : ''}] ${reviewers.join('+') || '(none)'} · docs:${touchesDocs} code:${touchesCode} api/data:${touchesApiData} sec:${securityRelevant}`)
@@ -964,8 +984,13 @@ async function runCard(cardId, cardPath) {
     // B6 — which reviewers ACTUALLY ran (the gated matrix); Phase Final keys its slim/skip
     // decision on this, and per_card telemetry records it for the A/B spawn accounting.
     reviewersRun: reviewers,
-    // B7 — Phase-1 specialist record (architect: done|inline-fallback; audit: pass|fixes|skipped-*).
+    // B7 — Phase-1 specialist record (architect: done|inline-fallback|inline-light; audit: pass|fixes|skipped-*).
     phase1,
+    // v5.4.1 minimal light lane — Phase Final keys its skip on these: a single light card whose
+    // per-card review surfaced NOTHING actionable has no post-fix state for the Final pass to
+    // verify (the Final review's purpose — v4.56.1 — is POST-fix verification, not re-review).
+    lightLane,
+    cleanReview: blocks.length === 0 && scopeExp.length === 0,
     scopeFiles, archBaselinePath: `/tmp/arch-baseline-${cardId}.md`, gates,
   }
 }
@@ -1141,7 +1166,13 @@ const committed = perCardResults.filter((r) => r.status === 'committed')
 phase('Final')
 let finalSummary = null
 let mergeBlocked = degraded
-if (committed.length && !degraded) {
+// v5.4.1 minimal light lane — ONE light card, clean per-card review (zero actionable
+// findings → zero fixes applied): the Final pass has nothing post-fix to verify and its
+// doc coverage already ran per-card (the light single-card matrix includes doc-reviewer).
+// Any finding/fix on the card, any second card, or any degradation → Final runs as always.
+const skipFinalLight = committed.length === 1 && committed[0].lightLane && committed[0].cleanReview && !degraded
+if (skipFinalLight) ledger(firstCard, 'final-review', 'SKIPPED', 'single light card, clean per-card review — nothing post-fix to verify (doc ran per-card)')
+if (committed.length && !degraded && !skipFinalLight) {
   const reviewScopeFiles = dedupe(committed.flatMap((r) => r.scopeFiles || []))
   const archPaths = committed.map((r) => r.archBaselinePath).filter(Boolean)
   const allArch = archPaths.length === committed.length ? archPaths : null
@@ -1285,7 +1316,11 @@ if (!committed.length) {
 // Phase Production (Phase 7) — non-blocking; report-not-execute (F-011 infra-deferred).
 // ───────────────────────────────────────────────────────────────────────────
 phase('Production')
-if (mergeResult && mergeResult.merged) {
+if (mergeResult && mergeResult.merged && committed.length && committed.every((r) => r.lightLane)) {
+  // v5.4.1 minimal light lane — light cards carry no deployable surface by Rule C (no
+  // migrations/indexes/cron/schema); the checklist would only burn a spawn to report zero items.
+  ledger(firstCard, 'phase7-production', 'SKIPPED', 'all-light batch — no deployable surface (Rule C)')
+} else if (mergeResult && mergeResult.merged) {
   try {
     // Schema-deploy-from-trunk-only invariant (v4.33.0): a remote schema/RLS/index/
     // migration deploy desyncs a shared remote datastore when run off-trunk. When the

package/framework/templates/primitives/AGENTS.CHANGELOG.md

@@ -4,6 +4,19 @@ Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://sem
 Questo è il changelog INTERNO dello skeleton spedito (`primitive_version`), separato dal
 file `AGENTS.md` generato nel consumer e indipendente dal `VERSION` del framework.
 
+## 1.8.0 — 2026-07-03
+
+- **§ Change Tiers — orchestrated-pipeline grounding exception.** Inside a `/new`/`new2`
+  run, a `review_profile: light|skip` card satisfies the (unchanged) understanding
+  obligation by the OWNER agent grounding inline instead of a dedicated
+  `codebase-architect` spawn — delegation waived at ≤3-file scale, obligation intact.
+  Driven by the FEAT-0067 post-mortem (a dedicated retriever per tiny card costs more
+  than the exploration it isolates). `balanced`/`deep` keep the spawn.
+- **§ Change Tiers — Heavy trigger refined.** "introduces a new DB schema / migration" →
+  "changes DB STRUCTURE"; an ADDITIVE index-only migration is no longer Heavy by itself
+  (it keeps Rule C `db_indexes` review depth + the api-perf gate). Prevents a perf index
+  riding along a small feature from multiplying the whole planning ceremony.
+
 ## 1.7.4 — 2026-07-03
 
 - **Commit-format MUST scoped to card-bound work — no borrowed card IDs, no inherited

package/framework/templates/primitives/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- baldart-primitive: name=AGENTS primitive_version=1.7.4
+<!-- baldart-primitive: name=AGENTS primitive_version=1.8.0
      This is the SHIPPED SKELETON. The writer (src/utils/root-primitives.js) strips
      this banner, resolves every {{ slot }} / {{> partial }} / {{#flag}} from
      baldart.config.yml (+ package.json/README), merges .baldart/overlays/AGENTS.md,
@@ -130,6 +130,12 @@ doubt, treat it as Light** and escalate only when a Heavy trigger is actually pr
 NOT part of this tier-gated machinery** — it precedes the tier decision and applies to Light
 too; only a Trivial one-liner or a bare symbol-presence Grep skips it, and any UI work —
 change OR a spec/responsive-grounded verification — always grounds via `PROFILE=ui`.
+**Orchestrated-pipeline exception (scale, not obligation):** inside a `/new`/`new2` run, a
+card authored `review_profile: light` or `skip` (Rule C: ≤3 files, no logic-risk signal)
+satisfies the understanding obligation by the owner agent grounding INLINE in its own
+context instead of a separate `codebase-architect` spawn — the obligation is unchanged,
+only the delegation is waived at that scale (a dedicated retriever for a ≤3-file diff costs
+more than the exploration it isolates). `balanced`/`deep` cards keep the dedicated spawn.
 
 - **Trivial** — a one-liner, typo, or obvious bug with a clear fix. Just do it.
 - **Light** — the default for most work. Any change that does **not** hit a Heavy trigger,
@@ -139,9 +145,13 @@ change OR a spec/responsive-grounded verification — always grounds via `PROFIL
   `codebase-architect` first** when the task needs real understanding (UI work — change or
   spec/responsive-grounded verification → `PROFILE=ui`).
   Docs stay in sync and the pre-commit gates still run.
-- **Heavy** — escalate ONLY when the change: introduces a new DB schema / migration; adds a
-  new external dependency; adds a new API contract / route or a new domain entity; is a wide
-  or cross-module refactor; or runs in parallel with other agents/sessions on shared files.
+- **Heavy** — escalate ONLY when the change: changes DB **structure** (new table, column,
+  constraint, RLS policy, or any destructive migration — an ADDITIVE index-only migration is
+  NOT by itself Heavy: it is a rollback-safe performance artifact that keeps its per-card
+  review depth via Rule C `db_indexes` and the api-perf gate, without multiplying the
+  planning ceremony); adds a new external dependency; adds a new API contract / route or a
+  new domain entity; is a wide or cross-module refactor; or runs in parallel with other
+  agents/sessions on shared files.
   → Full machinery: plan mode → reviewed plan (`plan-auditor` + `doc-reviewer`) → delegation
   to the domain agent → a git **worktree** (`/nw`) → a backlog card (when the backlog feature
   is on). Project overlays may add project-specific Heavy triggers.

package/framework/templates/primitives/CLAUDE.CHANGELOG.md

@@ -4,6 +4,12 @@ Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://sem
 Changelog INTERNO dello stub spedito (`primitive_version`), separato dal `CLAUDE.md`
 generato nel consumer e indipendente dal `VERSION` del framework.
 
+## 1.4.3 — 2026-07-03
+
+- Plan Mode section: parenthetical pointing to the new AGENTS.md § Change Tiers
+  orchestrated-pipeline exception (light|skip cards ground inline via the owner agent
+  inside `/new`/`new2`) — keeps the two primitives from drifting on the grounding rule.
+
 ## 1.4.2 — 2026-07-02
 
 - **Name the built-in `Explore` guard for the understanding step**: § Subagents now says the

package/framework/templates/primitives/CLAUDE.md

@@ -1,4 +1,4 @@
-<!-- baldart-primitive: name=CLAUDE primitive_version=1.4.2
+<!-- baldart-primitive: name=CLAUDE primitive_version=1.4.3
      SHIPPED SKELETON. The writer strips this banner, resolves {{ slot }}/{{#flag}} from
      baldart.config.yml, merges .baldart/overlays/CLAUDE.md, stamps a baldart-generated
      marker, and writes the result to the repo root.
@@ -23,7 +23,9 @@ understanding you don't already have, and **every UI task grounds via `PROFILE=u
 OR a verification/question whose correct answer needs design-system-spec or responsive/state
 grounding (e.g. "is page X already on the new layout, on desktop and tablet?") — even for a small
 tweak. Only a genuine Trivial one-liner or a bare symbol-presence check (does file X import Y)
-skips it. For a Heavy task:
+skips it. (Inside a `/new`/`new2` pipeline run, a `review_profile: light|skip` card grounds
+inline via its owner agent instead of a dedicated spawn — see `AGENTS.md` § Change Tiers,
+orchestrated-pipeline exception.) For a Heavy task:
 
 - Enter plan mode (`EnterPlanMode`) before writing code.
 - Invoke `codebase-architect` before writing the plan — never plan blind. Pass the

package/package.json

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