@event4u/agent-config 9.11.0 → 9.12.0

package/dist/agent-src/skills/ui-apply-generic/SKILL.md

@@ -0,0 +1,180 @@
+---
+model_tier: medium
+name: ui-apply-generic
+description: "Use when implementing a UI brief on a stack with no framework executor — Svelte, Astro, Angular, plain HTML. Carries the stack-independent contract; idiom comes from the stack corpus."
+personas:
+  - frontend-engineer
+domain: engineering
+workspaces:
+  - engineering
+packs:
+  - engineering-base
+---
+
+# ui-apply-generic
+
+> The `plain` lane used to be a name with nothing behind it. This skill is the
+> lane: it carries the implementation discipline that previously lived **only**
+> inside the framework executors, and it gets framework idiom from the 16-stack
+> corpus instead of from prose written here.
+>
+> That split is the whole point. One skill plus a corpus serves Svelte, Astro,
+> Angular, Alpine, htmx and everything future at once. Sixteen framework skills
+> would serve the same set and cost a single maintainer sixteen surfaces to keep
+> current — the enumeration this package refuses.
+
+## When to use
+
+- `state.stack.frontend` resolves to `plain`, or to a label with no
+  framework-specific overlay.
+- A stack whose `axes.reactivity` or `axes.meta` is recognised but has no
+  executor skill (`svelte`, `angular`, `astro`, `solid`, `qwik`, `htmx`).
+- As the base of a composition: an overlay skill (`livewire`, `flux`,
+  `blade-ui`, `react-shadcn-ui`) adds framework specifics **on top** of this
+  contract, it does not replace it.
+
+Do NOT use when a framework executor already covers the whole job — then this
+skill is the base and the executor is the overlay, dispatched together.
+
+## Procedure
+
+### Step 1 — Query the stack corpus (mandatory)
+
+Read `state.stack.axes` and query per resolved axis value, most specific first:
+`meta` → `reactivity` → `component_lib`.
+
+```bash
+<skills-root>/corpus-grounding/scripts/ground search \
+  --manifest <skills-root>/design-intelligence/data/manifest.json \
+  --stack <axis-value> "<the concrete question>"
+```
+
+`axes.meta: nuxt` with `axes.reactivity: vue` means **two** queries —
+`--stack nuxtjs` and `--stack vue`. A meta-framework does not replace the layer
+it wraps; that conflation is the defect the axes exist to fix.
+
+**Cite what you used.** The result names the corpus rows the implementation
+followed. An uncited pick is indistinguishable from the model's memory, and
+memory is exactly what the corpus exists to replace.
+
+**No corpus domain for the detected stack** → say so, in the result:
+
+> No stack corpus for `<stack>` — proceeding on the generic contract. Framework
+> idiom below is not grounded and should be reviewed by someone who knows this
+> stack.
+
+Silence is the failure mode. An unstated gap reads as grounded output.
+
+### Step 2 — Apply the stack-independent contract
+
+Every item is a hard requirement, and none of them is framework-specific:
+
+1. **Verbatim floor.** Microcopy comes from `state.ui_design.microcopy` exactly
+   as written — every label, empty-state line, and validation message. No
+   paraphrase, no improvement. Where a source artifact was provided, it beats
+   the brief (see `design-fidelity`).
+2. **Token discipline.** Colour, spacing, radius and shadow values come from the
+   project's tokens. A raw hex or arbitrary px that no token backs is a finding,
+   not a choice. Validate with `design-tokens`' `tokens validate`.
+3. **Component reuse.** Check `state.ui_audit.components_found` before creating
+   anything. In a run that has already added components, re-read the component
+   directories — the audit inventory is computed once per state-file and does
+   not refresh (see `existing-ui-audit` § Gotchas).
+4. **a11y floor.** Semantic elements over `div` + role; every interactive
+   element reachable and labelled; focus visible; contrast meets the project's
+   stated level, AA when unstated.
+5. **All five states.** `empty`, `loading`, `error`, `success`, `disabled` per
+   the brief. An explicit `n/a` is legitimate for a surface that genuinely has
+   no such state — declaring that is the opposite of inventing filler.
+6. **Asset discipline.** Copy referenced assets into the project's asset path.
+   Never hotlink; never fabricate a logo or a screenshot.
+7. **No placeholders.** `<placeholder>`, `lorem`, `todo:`, `tbd`, `xxx` are
+   rejected at the boundary — including inside arrays.
+
+### Step 3 — Verify, with honest degrade
+
+Exercise the result with whatever the host actually has, and name which:
+
+| Available | Do |
+|---|---|
+| Browser / Playwright | Render, check the states, exercise one interaction |
+| Screenshot only | Capture and inspect layout at 375 / 768 / 1280 |
+| Neither | Static inspection only, and **say** the render is unverified |
+
+Never claim a state or interaction works without having exercised it. A caveat
+is a finding; a silent claim is a defect.
+
+## Output format
+
+Four requirements, in order — each is checkable by a reader of the result:
+
+1. **Name the corpora queried**, or state that none exists for this stack.
+2. **Cite the rows that changed a decision** — not every row read.
+3. **State the verification method and its caveats**, never an unqualified
+   "works".
+4. **List components reused before components added**, so a duplicate is
+   visible rather than buried.
+
+Write `state.ticket["ui_apply"]`:
+
+```yaml
+ui_apply:
+  files: ["resources/js/UserCard.svelte"]
+  rendered:
+    "resources/js/UserCard.svelte": |
+      <full text, microcopy-locked>
+  components_added: ["UserCard"]
+  components_reused: ["Button"]
+  microcopy_lock: true
+  stack_corpus:                 # which corpora answered, or the degrade note
+    queried: ["svelte"]
+    cited: ["svelte.csv:12 — prefer stores over prop drilling"]
+  verify:
+    method: static_inspect      # or playwright / screenshot
+    caveats: ["render not verified — no browser available"]
+```
+
+## Gotchas
+
+- **Do not write framework prose into this skill.** The moment it explains how
+  Svelte stores work, it stops being one maintainable surface and starts being
+  sixteen. Framework knowledge belongs in the corpus.
+- **`axes.reactivity: unknown` is not `none`.** `unknown` means a project has
+  manifests and no recognised reactivity layer — proceed, and say the stack was
+  not recognised. `none` means there genuinely is no reactivity layer, which is
+  the normal shape for a static page.
+- **A meta-framework needs its own query.** Querying only `--stack vue` for a
+  Nuxt project silently drops the routing, data-fetching and SSR idioms that
+  are the whole reason Nuxt exists.
+- **The generic contract is a floor, not a ceiling.** Where an overlay skill is
+  dispatched with this one, its framework rules win on their subject.
+- **The floor now lives in exactly one place, and that is the point.** Overlay
+  composition applies this contract to every lane, so a future change to any of
+  its seven items is a one-point edit here rather than four lane patches that
+  drift apart. Concretely: the five-states requirement reaches every lane
+  through this skill. That requirement is deliberately unconditional — an
+  explicit `n/a` is the escape for a surface that genuinely has no such state
+  (asserted in `ui_lane_matrix.test.ts`), so this is not a defect being
+  broadened. But if the decision is ever revisited, revisit it here.
+
+## Do NOT
+
+- Emit framework code from memory and present it as grounded.
+- Skip the corpus query because the stack "looks obvious".
+- Claim a render or an interaction was verified when no primitive was available.
+- Invent states, sections, or copy the brief does not carry.
+- Treat a missing corpus as an evidence gap — it is a missing pack, and the two
+  must not be recorded the same way.
+
+## See also
+
+- [`design-intelligence`](../design-intelligence/SKILL.md) — the `--stack`
+  corpus this skill queries (16 stacks).
+- [`existing-ui-audit`](../existing-ui-audit/SKILL.md) — the inventory Step 2
+  checks, and its once-per-state-file limit.
+- [`design-tokens`](../design-tokens/SKILL.md) — `tokens validate`.
+- [`fe-design`](../fe-design/SKILL.md) — where the brief's selection decisions
+  come from, and what it does when the corpus is not installed.
+- [`ui-component-architect`](../ui-component-architect/SKILL.md),
+  [`tailwind-engineer`](../tailwind-engineer/SKILL.md) — stack-neutral
+  companions this skill composes with.

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "9.11.0"
+agent_config_version: "9.12.0"
 
 # --- Project identity ---
 project:

package/dist/agent-src/templates/scripts/work_engine/directives/ui/apply.ts

@@ -19,7 +19,7 @@ import {
 } from '../../delivery_state.js';
 import { placeholder_paths } from './design.js';
 import {
-    UNSUPPORTED_LANE,
+    is_ambiguous_stack,
     bundle_line,
     unsupported_stack_questions,
 } from './stack_bundles.js';
@@ -132,11 +132,15 @@ function _placeholder_violations_in_output(envelope: Record<string, Any>): strin
 function _delegate_to_stack_skill(state: DeliveryState): StepResult {
     const directive = _resolve_directive(state);
     const stack_label = _stack_label(state);
-    if (stack_label === UNSUPPORTED_LANE) {
+    if (is_ambiguous_stack(state.stack)) {
+        const conflicts = ((state.stack as Record<string, Any>)['ambiguity'] ??
+            []) as ReadonlyArray<string>;
         return new StepResult({
             outcome: Outcome.BLOCKED,
-            questions: unsupported_stack_questions('apply'),
-            message: 'UI apply refused: frontend framework not modelled by any lane.',
+            questions: unsupported_stack_questions('apply', conflicts),
+            message:
+                `UI apply halted: detection is ambiguous (${conflicts.join('; ')}) — ` +
+                'the open question is which project to build for.',
         });
     }
     return new StepResult({
@@ -144,7 +148,7 @@ function _delegate_to_stack_skill(state: DeliveryState): StepResult {
         questions: [
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Implementing the locked design brief.`,
-            bundle_line(stack_label, 'build'),
+            bundle_line(state.stack, 'build', stack_label),
             '> Microcopy is locked — every button label, empty-state ' +
                 'message, and validation message must come verbatim from ' +
                 '`state.ui_design.microcopy`.',

package/dist/agent-src/templates/scripts/work_engine/directives/ui/polish.ts

@@ -16,7 +16,7 @@ import {
     agent_directive,
 } from '../../delivery_state.js';
 import {
-    UNSUPPORTED_LANE,
+    is_ambiguous_stack,
     bundle_line,
     unsupported_stack_questions,
 } from './stack_bundles.js';
@@ -195,12 +195,15 @@ function _delegate_to_polish_skill(
     ceiling: number,
 ): StepResult {
     const directive = _resolve_directive(state);
-    const unsupported_label = _stack_label(state);
-    if (unsupported_label === UNSUPPORTED_LANE) {
+    if (is_ambiguous_stack(state.stack)) {
+        const conflicts = ((state.stack as Record<string, Any>)['ambiguity'] ??
+            []) as ReadonlyArray<string>;
         return new StepResult({
             outcome: Outcome.BLOCKED,
-            questions: unsupported_stack_questions('polish'),
-            message: 'UI polish refused: frontend framework not modelled by any lane.',
+            questions: unsupported_stack_questions('polish', conflicts),
+            message:
+                `UI polish halted: detection is ambiguous (${conflicts.join('; ')}) — ` +
+                'the open question is which project to build for.',
         });
     }
     const stack_label = _stack_label(state);
@@ -222,7 +225,7 @@ function _delegate_to_polish_skill(
         questions: [
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Polish round ${next_round} of ${ceiling}.`,
-            bundle_line(stack_label, 'build'),
+            bundle_line(state.stack, 'build', stack_label),
             findings_line,
             '> Fix chart-type / contrast findings against the adopted ' +
                 "corpus rows (design-intelligence § 'Grounding the " +

package/dist/agent-src/templates/scripts/work_engine/directives/ui/review.ts

@@ -17,7 +17,7 @@ import {
     agent_directive,
 } from '../../delivery_state.js';
 import {
-    UNSUPPORTED_LANE,
+    is_ambiguous_stack,
     bundle_line,
     unsupported_stack_questions,
 } from './stack_bundles.js';
@@ -192,11 +192,15 @@ function _stack_label(state: DeliveryState): string {
 function _delegate_to_review_skill(state: DeliveryState): StepResult {
     const directive = _resolve_directive(state);
     const stack_label = _stack_label(state);
-    if (stack_label === UNSUPPORTED_LANE) {
+    if (is_ambiguous_stack(state.stack)) {
+        const conflicts = ((state.stack as Record<string, Any>)['ambiguity'] ??
+            []) as ReadonlyArray<string>;
         return new StepResult({
             outcome: Outcome.BLOCKED,
-            questions: unsupported_stack_questions('review'),
-            message: 'UI review refused: frontend framework not modelled by any lane.',
+            questions: unsupported_stack_questions('review', conflicts),
+            message:
+                `UI review halted: detection is ambiguous (${conflicts.join('; ')}) — ` +
+                'the open question is which project to build for.',
         });
     }
     return new StepResult({
@@ -205,7 +209,7 @@ function _delegate_to_review_skill(state: DeliveryState): StepResult {
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Reviewing rendered components ` +
                 'against the locked design brief.',
-            bundle_line(stack_label, 'review'),
+            bundle_line(state.stack, 'review', stack_label),
             '> The review pass compares `state.ticket.ui_apply.rendered` ' +
                 'against `state.ui_design` (microcopy, states, a11y, layout) ' +
                 'and produces a structured `findings` list.',

package/dist/agent-src/templates/scripts/work_engine/directives/ui/stack_bundles.ts

@@ -39,14 +39,24 @@ export interface StackBundle {
 }
 
 /**
- * The pack-agnostic pair. Both live in `engineering-base`, so they are present
- * in every install; both self-describe as stack-neutral
- * (`ui-component-architect`: "the same lens applies to Blade, Livewire, React,
- * or Vue trees"; `tailwind-engineer`: "the **how** for any Tailwind-stack
- * screen"). This is the honest floor for a lane with no framework-specific
- * executor — not a claim that the lane is fully served.
+ * The stack-neutral build bundle. All three live in `engineering-base`, so they
+ * are present in every install.
+ *
+ * `ui-apply-generic` leads: it carries the implementation contract that used to
+ * exist only inside the framework executors, and it pulls framework idiom from
+ * the 16-stack corpus rather than from prose. That is what turns this lane from
+ * an honest refusal into actual coverage for Svelte, Astro, Angular and
+ * anything future — without minting a skill per framework.
+ *
+ * The other two are the companions it composes with: `ui-component-architect`
+ * ("the same lens applies to Blade, Livewire, React, or Vue trees") and
+ * `tailwind-engineer` ("the **how** for any Tailwind-stack screen").
  */
-const GENERIC_BUILD: ReadonlyArray<string> = ['ui-component-architect', 'tailwind-engineer'];
+const GENERIC_BUILD: ReadonlyArray<string> = [
+    'ui-apply-generic',
+    'ui-component-architect',
+    'tailwind-engineer',
+];
 
 /** `design-review` is stack-neutral and ships in `engineering-base`. */
 const GENERIC_REVIEW: ReadonlyArray<string> = ['design-review'];
@@ -57,6 +67,16 @@ const GENERIC_REVIEW: ReadonlyArray<string> = ['design-review'];
  * contract) and consume this map only to name the skills in the halt body.
  */
 export const STACK_BUNDLES: Readonly<Record<string, StackBundle>> = {
+    // An unmodelled framework routes to the generic lane rather than refusing:
+    // `ui-apply-generic` queries the stack corpus, which covers svelte, astro,
+    // angular, nuxt and eleven more. Refusing while holding that corpus is the
+    // "an honest refusal is not coverage" defect. A genuine ambiguity still
+    // refuses — see `is_ambiguous_stack`.
+    unknown: {
+        build: GENERIC_BUILD,
+        review: GENERIC_REVIEW,
+        pack_agnostic: true,
+    },
     'blade-livewire-flux': {
         build: ['flux', 'livewire', 'blade-ui'],
         review: GENERIC_REVIEW,
@@ -113,7 +133,7 @@ export const STACK_BUNDLES: Readonly<Record<string, StackBundle>> = {
  * definite idiom and the package has no executor for it, so the result must not
  * read as Vue support.
  */
-export const GENERIC_LANES: ReadonlySet<string> = new Set(['vue', 'plain']);
+export const GENERIC_LANES: ReadonlySet<string> = new Set(['vue', 'plain', 'unknown']);
 
 /** Lanes where the stack-neutral pair is the correct answer, not a shortfall. */
 const NATIVELY_GENERIC_LANES: ReadonlySet<string> = new Set(['plain']);
@@ -126,31 +146,81 @@ const NATIVELY_GENERIC_LANES: ReadonlySet<string> = new Set(['plain']);
  */
 export const UNSUPPORTED_LANE = 'unknown';
 
-/** Return the bundle for `stack`, or the `plain` bundle when unmapped. */
-export function bundle_for(stack: string): StackBundle {
-    return STACK_BUNDLES[stack] ?? (STACK_BUNDLES['plain'] as StackBundle);
+/**
+ * Return the bundle for a stack state.
+ *
+ * Composition wins when the state carries axes; the hand-written map is the
+ * fallback for a legacy `state.stack` persisted before Detection v2. Keeping
+ * both is not indecision — a state file written by an older run must still
+ * dispatch, and the map is exactly what it expects.
+ */
+export function bundle_for(stack_state: unknown): StackBundle {
+    if (typeof stack_state === 'object' && stack_state !== null) {
+        const raw = (stack_state as Record<string, unknown>)['axes'];
+        if (typeof raw === 'object' && raw !== null) {
+            return compose_bundle(raw as Record<string, string>);
+        }
+        const label = (stack_state as Record<string, unknown>)['frontend'];
+        if (typeof label === 'string' && label in STACK_BUNDLES) {
+            return STACK_BUNDLES[label] as StackBundle;
+        }
+    }
+    if (typeof stack_state === 'string' && stack_state in STACK_BUNDLES) {
+        return STACK_BUNDLES[stack_state] as StackBundle;
+    }
+    return STACK_BUNDLES['plain'] as StackBundle;
+}
+
+/**
+ * True when the `unknown` label came from a question, not from a coverage gap.
+ *
+ * `unknown` carries two different situations and they need opposite handling:
+ *
+ * - **An unmodelled framework** (svelte, astro, angular …). Since
+ *   `ui-apply-generic` exists and queries the stack corpus, refusing here would
+ *   be the "an honest refusal is not coverage" defect — the corpus almost
+ *   certainly HAS the stack. Route to the generic lane, naming the framework.
+ * - **A genuine ambiguity** — two SPA frameworks in one manifest, or several
+ *   workspace roots. No executor can fix that: the open question is *which
+ *   project is this*, and only the caller can answer. Refuse.
+ *
+ * `StackResult.ambiguity` is what distinguishes them, so the check is on the
+ * ambiguity list rather than on the label.
+ */
+export function is_ambiguous_stack(stack_state: unknown): boolean {
+    if (typeof stack_state !== 'object' || stack_state === null) return false;
+    const raw = (stack_state as Record<string, unknown>)['ambiguity'];
+    return Array.isArray(raw) && raw.length > 0;
 }
 
 /**
- * Questions for the refusal halt on an unmodelled framework.
+ * Questions for the refusal halt when detection cannot say what the project is.
  *
- * Not a directive — there is nothing honest to dispatch to. The agent names
- * the actual markers from the manifest (it has filesystem access; the engine
- * deliberately does not carry them on `StackResult`), and the user chooses
- * between the stack-neutral floor and stopping.
+ * Not a directive — there is nothing honest to dispatch to, because the missing
+ * input is a decision rather than a skill. `conflicts` are echoed verbatim from
+ * `StackResult.ambiguity` so the user sees the actual collision.
  */
-export function unsupported_stack_questions(step: string): string[] {
-    return [
-        '> Detection found a frontend framework this package does not model, ' +
-            `so there is no \`${step}\` lane for it.`,
-        '> Name the markers you see in `composer.json` / `package.json` so the ' +
-            'choice below is made on the real stack, not on a guess.',
-        '> 1. Continue on the stack-neutral floor — `ui-component-architect` + ' +
-            '`tailwind-engineer`. Output will not be idiomatic for this ' +
-            'framework; say so in the result.',
-        '> 2. Abort — drop this UI request and add a lane first ' +
-            '(`docs/contracts/ui-stack-extension.md`).',
+export function unsupported_stack_questions(
+    step: string,
+    conflicts: ReadonlyArray<string> = [],
+): string[] {
+    const lines = [
+        '> Detection found conflicting signals, so it will not pick a stack for ' +
+            `you at \`${step}\`. Guessing here is the failure this halt exists ` +
+            'to prevent.',
     ];
+    for (const c of conflicts) {
+        lines.push(`> - \`${c}\``);
+    }
+    lines.push(
+        '> 1. Name the project to build for — the workspace path, or which ' +
+            'framework owns this surface. Detection re-runs against that scope.',
+        '> 2. Continue on the stack-neutral floor anyway — `ui-apply-generic` ' +
+            'plus its companions. Output will not be idiomatic for either ' +
+            'framework; say so in the result.',
+        '> 3. Abort — drop this UI request.',
+    );
+    return lines;
 }
 
 /**
@@ -161,8 +231,19 @@ export function unsupported_stack_questions(step: string): string[] {
  * framework-specific executor says that outright rather than presenting the
  * generic pair as if it were stack support.
  */
-export function bundle_line(stack: string, role: 'build' | 'review'): string {
-    const bundle = bundle_for(stack);
+export function bundle_line(
+    stack_state: unknown,
+    role: 'build' | 'review',
+    stack_label?: string,
+): string {
+    const bundle = bundle_for(stack_state);
+    const stack =
+        stack_label ??
+        (typeof stack_state === 'string'
+            ? stack_state
+            : String(
+                  (stack_state as Record<string, unknown> | null)?.['frontend'] ?? 'plain',
+              ));
     const skills = role === 'review' ? bundle.review : bundle.build;
     const rendered = skills.map((name) => `\`${name}\``).join(' + ');
     if (NATIVELY_GENERIC_LANES.has(stack)) {
@@ -177,3 +258,75 @@ export function bundle_line(stack: string, role: 'build' | 'review'): string {
     }
     return `> Skills: ${rendered}.`;
 }
+
+// ── Axis-driven composition ─────────────────────────────────────────────────
+
+/**
+ * Overlay table: one axis value → the skills that add its idiom.
+ *
+ * This is what replaces lane enumeration. A lane is no longer a hand-written
+ * bundle but the base plus whatever the axes turn on, so a stack the package has
+ * never named still composes: `reactivity: livewire` pulls Livewire **with or
+ * without** Flux, and `component_lib: flux` layers Flux on top. The two
+ * full-match lanes fall out as a special case — that identity is the regression
+ * witness, asserted in `ui_lane_matrix.test.ts`.
+ *
+ * Only axis values with a real overlay skill appear. Everything else is served
+ * by the base plus its corpus query, which is the point: coverage without a
+ * skill per framework.
+ */
+const _AXIS_OVERLAYS: Readonly<Record<string, ReadonlyArray<string>>> = {
+    'reactivity:livewire': ['livewire'],
+    'reactivity:react': ['react-shadcn-ui'],
+    'component_lib:flux': ['flux'],
+    'component_lib:shadcn': ['react-shadcn-ui'],
+    'component_lib:radix': ['react-shadcn-ui'],
+    'view:blade': ['blade-ui'],
+    'meta:filament': ['livewire', 'blade-ui'],
+};
+
+/** Axes consulted for overlays, most-specific first. */
+const _OVERLAY_AXES: ReadonlyArray<string> = [
+    'component_lib',
+    'meta',
+    'reactivity',
+    'view',
+];
+
+/** Skill → the pack it ships in, for the pack-agnostic determination. */
+const _FRAMEWORK_PACK_SKILLS: ReadonlySet<string> = new Set([
+    'livewire',
+    'flux',
+    'blade-ui',
+    'react-shadcn-ui',
+]);
+
+/**
+ * Derive a bundle from detected axes.
+ *
+ * Order is deliberate and matches the hand-written lanes: overlays first
+ * (most-specific axis first), base last. An overlay carries framework idiom the
+ * base cannot, so it must be read before the generic contract's fallbacks.
+ *
+ * `pack_agnostic` is computed, not declared: a composition that pulled in any
+ * framework-pack skill is not safe as a fallback, and computing it removes the
+ * chance of a hand-written `true` outliving the bundle it described.
+ */
+export function compose_bundle(axes: Readonly<Record<string, string>>): StackBundle {
+    const build: string[] = [];
+    for (const axis of _OVERLAY_AXES) {
+        const value = axes[axis];
+        if (value === undefined || value === 'none' || value === 'unknown') continue;
+        for (const skill of _AXIS_OVERLAYS[`${axis}:${value}`] ?? []) {
+            if (!build.includes(skill)) build.push(skill);
+        }
+    }
+    for (const skill of GENERIC_BUILD) {
+        if (!build.includes(skill)) build.push(skill);
+    }
+    return {
+        build,
+        review: GENERIC_REVIEW,
+        pack_agnostic: !build.some((s) => _FRAMEWORK_PACK_SKILLS.has(s)),
+    };
+}