@mmerterden/multi-agent-pipeline 20.17.0 → 20.17.2

package/pipeline/skills/shared/external/swiftui-liquid-glass/references/liquid-glass.md

@@ -1,7 +1,29 @@
 # Liquid Glass API Reference
 
 Signatures and behaviour behind the `swiftui-liquid-glass` skill. Read its
-SKILL.md for the workflow and examples; this file is the detail.
+SKILL.md first for where glass belongs and the workflow; this file is the
+SwiftUI detail. UIKit is in [uikit-glass.md](uikit-glass.md).
+
+## Contents
+
+- [Overview](#overview)
+- [glassEffect(_:in:)](#glasseffect_in)
+- [Glass](#glass)
+- [Clear glass and the dimming layer](#clear-glass-and-the-dimming-layer)
+- [GlassEffectContainer](#glasseffectcontainer)
+- [glassEffectID(_:in:)](#glasseffectid_in)
+- [glassEffectUnion(id:namespace:)](#glasseffectunionidnamespace)
+- [glassEffectTransition(_:) and GlassEffectTransition](#glasseffecttransition_-and-glasseffecttransition)
+- [Button styles](#button-styles)
+- [DefaultGlassEffectShape](#defaultglasseffectshape)
+- [Concentric shapes](#concentric-shapes)
+- [Custom bars: safeAreaBar](#custom-bars-safeareabar)
+- [Scroll edge effect](#scroll-edge-effect)
+- [Background extension (split views)](#background-extension-split-views)
+- [Availability gating](#availability-gating)
+- [Performance guidelines](#performance-guidelines)
+- [Examples](#examples)
+- [Apple documentation links](#apple-documentation-links)
 
 ## Overview
 
@@ -53,6 +75,33 @@ struct Glass: Equatable, Sendable {
 `interactive(_:)` hands back one that responds to fingers and pointer hover.
 Being `Sendable`, a `Glass` value can be computed anywhere and handed to a view.
 
+## Clear glass and the dimming layer
+
+`.clear` is highly translucent and meant for components that float over
+photos and video. When the media behind it is bright, put a dark dimming layer
+underneath; Apple's HIG suggests 35% black. Over dark media, or with AVKit's
+standard playback controls, skip it.
+
+```swift
+@available(iOS 26, *)
+struct PhotoOverlayControls: View {
+    var body: some View {
+        HStack(spacing: 16) {
+            Button("Share", systemImage: "square.and.arrow.up") { }
+            Button("Favorite", systemImage: "heart") { }
+        }
+        .labelStyle(.iconOnly)
+        .font(.title3)
+        .padding()
+        .glassEffect(.clear.interactive())
+        .background(.black.opacity(0.35), in: .capsule)
+    }
+}
+```
+
+Choose `.regular` instead whenever the component carries much text or sits
+over content whose brightness you do not control.
+
 ## GlassEffectContainer
 
 A generic `View` over its `Content`, isolated to the main actor (declared
@@ -134,12 +183,78 @@ a `Button` yourself.
 
 The default `in:` argument of `glassEffect`. It resolves to a `Capsule`.
 
+## Concentric shapes
+
+`ConcentricRectangle` (iOS 26) is a shape whose corners can be concentric with
+a container's corners, fixed, or square. A corner is concentric when its radius
+shares a center with the container's rounded corner, which is how sheets
+follow the curve of the screen.
+
+| Initializer or style | Result |
+|---|---|
+| `ConcentricRectangle()` | Every corner concentric with the container |
+| `ConcentricRectangle(corners: .concentric(minimum: 12), isUniform: true)` | Concentric, never below 12 points, all corners equal |
+| `ConcentricRectangle(uniformTopCorners: .fixed(12), uniformBottomCorners: .concentric)` | Fixed top, concentric bottom, like a format sheet |
+
+The container is the device edge, a system container such as a sheet, or any
+view that sets `containerShape(_:)` with a `RoundedRectangularShape`
+(`RoundedRectangle`, `Capsule`, `Circle`, `Rectangle`). When a corner sits far
+from the container's corner the computed radius can be zero, so use
+`.concentric(minimum:)` where the corner must stay rounded.
+
+```swift
+@available(iOS 26, *)
+struct NestedPanel: View {
+    var body: some View {
+        VStack(spacing: 12) {
+            Text("Boarding").font(.headline)
+            Button("Show pass") { }
+                .buttonStyle(.glassProminent)
+        }
+        .padding(16)
+        .background(.thinMaterial, in: ConcentricRectangle(corners: .concentric(minimum: 12), isUniform: true))
+        .containerShape(RoundedRectangle(cornerRadius: 28))
+    }
+}
+```
+
+HIG asks custom components in toolbars to keep their corner radius
+concentric with the bar, as standard components do.
+
+## Custom bars: safeAreaBar
+
+`safeAreaBar(edge:alignment:spacing:content:)` (iOS 26) works like
+`safeAreaInset`, and also extends the scroll edge effect of scroll views
+under the inset, so a custom bar gets the same legibility treatment as a
+system toolbar.
+
+```swift
+@available(iOS 26, *)
+struct ComposerScreen: View {
+    @State private var draft = ""
+
+    var body: some View {
+        ScrollView { MessageList() }
+            .safeAreaBar(edge: .bottom) {
+                HStack {
+                    TextField("Message", text: $draft)
+                    Button("Send", systemImage: "paperplane.fill") { }
+                        .buttonStyle(.glassProminent)
+                }
+                .padding()
+            }
+    }
+}
+```
+
 ## Scroll edge effect
 
-A nonisolated modifier taking an optional `ScrollEdgeEffectStyle` and, after
-`for:`, an `Edge.Set`. Styles are `.automatic`, `.soft` (a gradual fade) and `.hard` (a crisper cut
-off). System bars already apply an edge effect; set the style yourself for
-custom bars that float over scrolling content, or to change the look.
+`scrollEdgeEffectStyle(_:for:)` takes an optional `ScrollEdgeEffectStyle` and,
+after `for:`, an `Edge.Set`. Styles are `.automatic`, `.soft` (a gradual fade)
+and `.hard` (a crisper cut off). `scrollEdgeEffectHidden(_:for:)` hides the
+effect. System bars already apply an edge effect; adjust it for custom bars
+that float over scrolling content. Remove custom darkening gradients behind
+bar items, which fight the effect.
 
 ## Background extension (split views)
 
@@ -162,17 +277,6 @@ NavigationSplitView {
 }
 ```
 
-## ToolbarSpacer
-
-```swift
-struct ToolbarSpacer: ToolbarContent {
-    init(_ sizing: SpacerSizing = .flexible, placement: ToolbarItemPlacement = .automatic)
-}
-```
-
-`.fixed` inserts a fixed gap that separates glass groups; `.flexible` pushes
-groups apart. Available on iOS and macOS 26.
-
 ## Availability gating
 
 Every API above needs iOS 26. Give older systems a material background of the
@@ -198,27 +302,131 @@ extension View {
 - Prefer one container per group over many small containers.
 - Measure with Instruments (SwiftUI and Core Animation templates) before and
   after adding glass to scrolling content.
+- Apple notes that combining custom glass in a `GlassEffectContainer` helps
+  rendering performance as well as morphing.
+
+## Examples
+
+### A gated glass card for a floating summary
 
-## Accessibility considerations
+```swift
+struct StatusPill: View {
+    let title: String
+
+    var body: some View {
+        let label = Text(title).font(.headline).padding(20)
 
-- **Reduce Transparency**: system components switch to a more opaque
-  appearance on their own. Check that custom glass still reads well.
-- **Reduce Motion**: morphing and fluid animations are toned down. Make sure
-  the interface still makes sense without them.
-- **Contrast**: text and icons over glass need enough contrast against
-  whatever may scroll behind them.
+        if #available(iOS 26, *) {
+            label.glassEffect(.regular.interactive(), in: .rect(cornerRadius: 18))
+        } else {
+            label.background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 18))
+        }
+    }
+}
+```
 
-## Best practices summary
+### A row of glass controls
 
-1. Glass that shares the screen shares a `GlassEffectContainer`.
-2. `.glassEffect()` goes last, once size and styling are settled.
-3. The container's spacing equals the stack's spacing (or exceeds it).
-4. Only controls get `.interactive()`.
-5. Morphing needs `glassEffectID` plus a change inside `withAnimation`.
-6. Buttons take `.glass` or `.glassProminent`.
-7. Fewer glass surfaces read better than many.
-8. Anything glass sits behind an iOS 26 check with a fallback.
-9. Every screen is checked once with Reduce Transparency, once with Reduce Motion.
+Container spacing matches the stack spacing so the circles blend only when
+they move toward each other.
+
+```swift
+@available(iOS 26, *)
+struct PlaybackControls: View {
+    private let symbols = ["backward.fill", "play.fill", "forward.fill"]
+    private let gap: CGFloat = 20
+
+    var body: some View {
+        GlassEffectContainer(spacing: gap) {
+            HStack(spacing: gap) {
+                ForEach(symbols, id: \.self) { symbol in
+                    Image(systemName: symbol)
+                        .font(.title2)
+                        .frame(width: 60, height: 60)
+                        .glassEffect(.regular.interactive())
+                }
+            }
+        }
+    }
+}
+```
+
+### Morphing between states
+
+```swift
+@available(iOS 26, *)
+struct ExpandingActions: View {
+    @Namespace private var glassSpace
+    @State private var expanded = false
+
+    var body: some View {
+        let gap: CGFloat = 36
+        return GlassEffectContainer(spacing: gap) {
+            HStack(spacing: gap) {
+                Button("Compose", systemImage: "square.and.pencil") {
+                    withAnimation(.bouncy) { expanded.toggle() }
+                }
+                .buttonStyle(.glass)
+                .glassEffectID("compose", in: glassSpace)
+
+                if expanded {
+                    Button("Attach", systemImage: "paperclip") { }
+                        .buttonStyle(.glass)
+                        .glassEffectID("attach", in: glassSpace)
+                }
+            }
+        }
+    }
+}
+```
+
+### Merging shapes with a union
+
+```swift
+@available(iOS 26, *)
+struct FilterChips: View {
+    @Namespace private var chipSpace
+    let filters = ["Today", "Week", "Month", "Year"]
+
+    var body: some View {
+        let gap: CGFloat = 12
+        return GlassEffectContainer(spacing: gap) {
+            HStack(spacing: gap) {
+                ForEach(filters.indices, id: \.self) { index in
+                    Text(filters[index])
+                        .padding(.horizontal, 14)
+                        .padding(.vertical, 8)
+                        .glassEffect()
+                        .glassEffectUnion(id: index < 2 ? "short" : "long", namespace: chipSpace)
+                }
+            }
+        }
+    }
+}
+```
+
+Chips 0 and 1 render as one glass shape and chips 2 and 3 as another.
+
+### A solid fallback under Reduce Transparency
+
+System glass adapts on its own. A custom surface that must stay legible over
+busy content can switch to a solid fill when the setting is on:
+
+```swift
+@available(iOS 26, *)
+struct MapControlStrip: View {
+    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency
+
+    var body: some View {
+        let controls = HStack { LocateButton(); LayersButton() }.padding(12)
+        if reduceTransparency {
+            controls.background(Color(uiColor: .secondarySystemBackground), in: .capsule)
+        } else {
+            controls.glassEffect(.regular.interactive())
+        }
+    }
+}
+```
 
 ## Apple documentation links
 
@@ -231,3 +439,8 @@ extension View {
 - [GlassEffectTransition](https://developer.apple.com/documentation/swiftui/glasseffecttransition)
 - [GlassButtonStyle](https://developer.apple.com/documentation/swiftui/glassbuttonstyle)
 - [GlassProminentButtonStyle](https://developer.apple.com/documentation/swiftui/glassprominentbuttonstyle)
+- [ConcentricRectangle](https://developer.apple.com/documentation/swiftui/concentricrectangle)
+- [safeAreaBar(edge:alignment:spacing:content:)](https://developer.apple.com/documentation/swiftui/view/safeareabar(edge:alignment:spacing:content:))
+- [scrollEdgeEffectStyle(_:for:)](https://developer.apple.com/documentation/swiftui/view/scrolledgeeffectstyle(_:for:))
+- [backgroundExtensionEffect()](https://developer.apple.com/documentation/swiftui/view/backgroundextensioneffect())
+- [HIG: Materials](https://developer.apple.com/design/human-interface-guidelines/materials)

package/pipeline/skills/shared/external/swiftui-liquid-glass/references/uikit-glass.md

@@ -0,0 +1,227 @@
+# Liquid Glass in UIKit
+
+UIKit side of the `swiftui-liquid-glass` skill. Where glass belongs, regular
+versus clear, and the accessibility rules are in `../SKILL.md` and apply
+unchanged here. Every API in this file is iOS, iPadOS, Mac Catalyst and tvOS
+26.0 unless noted.
+
+## Contents
+
+- [Standard components first](#standard-components-first)
+- [UIGlassEffect](#uiglasseffect)
+- [UIGlassContainerEffect](#uiglasscontainereffect)
+- [Glass buttons](#glass-buttons)
+- [Corners: UICornerConfiguration](#corners-uicornerconfiguration)
+- [Scroll edge effects](#scroll-edge-effects)
+- [UIBackgroundExtensionView](#uibackgroundextensionview)
+- [Fallback and accessibility](#fallback-and-accessibility)
+- [Opting out for one release](#opting-out-for-one-release)
+- [Links](#links)
+
+## Standard components first
+
+`UINavigationBar`, `UITabBar`, `UIToolbar`, sheets, popovers and standard
+controls adopt the material when built with the 26 SDK. Remove custom bar
+background images and appearance colors that sat behind items: they overlay
+the glass and the scroll edge effect. Popovers that add their own
+`UIVisualEffectView` background should drop it.
+
+## UIGlassEffect
+
+A `UIVisualEffect` subclass rendering the glass material, hosted in a
+`UIVisualEffectView`. Content goes in the effect view's `contentView`.
+
+| Member | Meaning |
+|---|---|
+| `init(style:)` | `UIGlassEffect.Style.regular` or `.clear` |
+| `isInteractive` | Reacts to touch like system glass controls |
+| `tintColor` | Colors the glass for prominence; keep for one primary action or a status |
+
+```swift
+@available(iOS 26, *)
+@MainActor
+func makeGlassBadge(text: String) -> UIVisualEffectView {
+    let glass = UIGlassEffect(style: .regular)
+    glass.isInteractive = true
+
+    let glassView = UIVisualEffectView(effect: glass)
+    glassView.cornerConfiguration = .capsule()
+
+    let label = UILabel()
+    label.text = text
+    label.font = .preferredFont(forTextStyle: .headline)
+    label.adjustsFontForContentSizeCategory = true
+    label.translatesAutoresizingMaskIntoConstraints = false
+    glassView.contentView.addSubview(label)
+
+    NSLayoutConstraint.activate([
+        label.leadingAnchor.constraint(equalTo: glassView.contentView.leadingAnchor, constant: 16),
+        label.trailingAnchor.constraint(equalTo: glassView.contentView.trailingAnchor, constant: -16),
+        label.topAnchor.constraint(equalTo: glassView.contentView.topAnchor, constant: 8),
+        label.bottomAnchor.constraint(equalTo: glassView.contentView.bottomAnchor, constant: -8),
+    ])
+    return glassView
+}
+```
+
+The same placement rule applies as in SwiftUI: navigation and controls only.
+
+## UIGlassContainerEffect
+
+Renders several glass elements as one combined effect, so they blend and merge
+when close, the UIKit counterpart of `GlassEffectContainer`. Put a
+`UIVisualEffectView` with a `UIGlassContainerEffect` around nested
+`UIVisualEffectView`s that each use a `UIGlassEffect`, added to the
+container's `contentView`. `spacing` sets the distance at which neighbours
+start to merge.
+
+```swift
+@available(iOS 26, *)
+@MainActor
+func makeControlCluster(_ buttons: [UIView]) -> UIVisualEffectView {
+    let containerEffect = UIGlassContainerEffect()
+    containerEffect.spacing = 12
+    let container = UIVisualEffectView(effect: containerEffect)
+
+    let stack = UIStackView()
+    stack.axis = .horizontal
+    stack.spacing = 12
+    stack.translatesAutoresizingMaskIntoConstraints = false
+
+    for button in buttons {
+        let glassView = UIVisualEffectView(effect: UIGlassEffect(style: .regular))
+        glassView.cornerConfiguration = .capsule()
+        button.translatesAutoresizingMaskIntoConstraints = false
+        glassView.contentView.addSubview(button)
+        NSLayoutConstraint.activate([
+            button.centerXAnchor.constraint(equalTo: glassView.contentView.centerXAnchor),
+            button.centerYAnchor.constraint(equalTo: glassView.contentView.centerYAnchor),
+            glassView.widthAnchor.constraint(equalToConstant: 48),
+            glassView.heightAnchor.constraint(equalToConstant: 48),
+        ])
+        stack.addArrangedSubview(glassView)
+    }
+
+    container.contentView.addSubview(stack)
+    NSLayoutConstraint.activate([
+        stack.leadingAnchor.constraint(equalTo: container.contentView.leadingAnchor),
+        stack.trailingAnchor.constraint(equalTo: container.contentView.trailingAnchor),
+        stack.topAnchor.constraint(equalTo: container.contentView.topAnchor),
+        stack.bottomAnchor.constraint(equalTo: container.contentView.bottomAnchor),
+    ])
+    return container
+}
+```
+
+## Glass buttons
+
+Prefer a configuration to building glass around a `UIButton` by hand.
+
+| Configuration | Use |
+|---|---|
+| `UIButton.Configuration.glass()` | Regular glass button |
+| `.prominentGlass()` | The primary action |
+| `.clearGlass()` | Over rich media |
+| `.prominentClearGlass()` | Primary action over rich media |
+
+```swift
+@available(iOS 26, *)
+@MainActor
+func makeDoneButton(action: UIAction) -> UIButton {
+    var configuration = UIButton.Configuration.prominentGlass()
+    configuration.title = String(localized: "Done")
+    return UIButton(configuration: configuration, primaryAction: action)
+}
+```
+
+## Corners: UICornerConfiguration
+
+`UIView.cornerConfiguration` (iOS 26, also visionOS 26) takes a
+`UICornerConfiguration` built from `UICornerRadius` values.
+
+| Expression | Result |
+|---|---|
+| `.corners(radius: 12)` | Fixed radius on every corner |
+| `.corners(radius: .containerConcentric())` | Concentric with the containing view |
+| `.corners(radius: .containerConcentric(minimum: 10))` | Concentric, never below 10 points |
+| `.capsule()` | Capsule; `maximumRadius:` lets tall views break the capsule |
+| `.uniformTopRadius(_:bottomLeftRadius:bottomRightRadius:)` and siblings | Mixed uniform and independent corners |
+
+Squared corners are the default.
+
+## Scroll edge effects
+
+Each `UIScrollView` has `topEdgeEffect`, `bottomEdgeEffect`, `leftEdgeEffect`
+and `rightEdgeEffect`, each a `UIScrollEdgeEffect` (also visionOS 26) with:
+
+- `style`: `UIScrollEdgeEffect.Style.automatic`, `.soft` or `.hard`
+- `isHidden`: turns the effect off for that edge
+
+```swift
+scrollView.topEdgeEffect.style = .hard
+scrollView.bottomEdgeEffect.isHidden = false
+```
+
+A custom bar that floats over the edge of a scroll view registers with
+`UIScrollEdgeElementContainerInteraction`, so its labels, images, glass views
+and controls shape the edge effect:
+
+```swift
+let interaction = UIScrollEdgeElementContainerInteraction()
+interaction.scrollView = scrollView
+interaction.edge = .bottom
+buttonContainer.addInteraction(interaction)
+```
+
+## UIBackgroundExtensionView
+
+A view that can be laid out past the safe area, for example under a sidebar or
+inspector, while keeping its `contentView` inside the safe area and filling the
+rest with modified copies of the content's edges. It is the UIKit counterpart
+of `backgroundExtensionEffect()`. `automaticallyPlacesContentView` defaults to
+`true`; set it to `false` to position the content view yourself.
+
+```swift
+@available(iOS 26, *)
+@MainActor
+func makeHeroBackground(image: UIImage) -> UIBackgroundExtensionView {
+    let extensionView = UIBackgroundExtensionView()
+    let imageView = UIImageView(image: image)
+    imageView.contentMode = .scaleAspectFill
+    extensionView.contentView = imageView
+    return extensionView
+}
+```
+
+Use it for the backdrop of a split view's secondary column, not for every
+view.
+
+## Fallback and accessibility
+
+- Before iOS 26, use `UIVisualEffectView(effect: UIBlurEffect(style: .systemThinMaterial))`
+  (or another system material) with the same shape. Gate with
+  `if #available(iOS 26, *)`.
+- `UIAccessibility.isReduceTransparencyEnabled` and
+  `reduceTransparencyStatusDidChangeNotification` tell a custom surface when to
+  swap to an opaque background. `UIAccessibility.isDarkerSystemColorsEnabled`
+  reports Increase Contrast.
+- Text inside glass uses Dynamic Type (`preferredFont(forTextStyle:)` with
+  `adjustsFontForContentSizeCategory`) and semantic label colors.
+
+## Opting out for one release
+
+`UIDesignRequiresCompatibility` set to `YES` in Info.plist keeps the
+previous-SDK look while building with the 26 SDK. Apple describes it as
+temporary, and the system ignores it for apps built for the 27 SDKs. See
+`../SKILL.md`.
+
+## Links
+
+- [UIGlassEffect](https://developer.apple.com/documentation/uikit/uiglasseffect)
+- [UIGlassContainerEffect](https://developer.apple.com/documentation/uikit/uiglasscontainereffect)
+- [UIScrollEdgeEffect](https://developer.apple.com/documentation/uikit/uiscrolledgeeffect)
+- [UIScrollEdgeElementContainerInteraction](https://developer.apple.com/documentation/uikit/uiscrolledgeelementcontainerinteraction)
+- [UIBackgroundExtensionView](https://developer.apple.com/documentation/uikit/uibackgroundextensionview)
+- [UICornerConfiguration](https://developer.apple.com/documentation/uikit/uicornerconfiguration-swift.struct)
+- [UIButton.Configuration.glass()](https://developer.apple.com/documentation/uikit/uibutton/configuration-swift.struct/glass())
+- [UIDesignRequiresCompatibility](https://developer.apple.com/documentation/bundleresources/information-property-list/uidesignrequirescompatibility)

package/pipeline/skills/shared/external/swiftui-patterns/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: swiftui-patterns
-description: "SwiftUI Model-View structure: @Observable ownership, @State, @Bindable, @Environment, view decomposition, custom ViewModifiers, .task loading, iOS 26 APIs, Writing Tools. Use when structuring a SwiftUI app, managing state, composing or splitting views, or adopting iOS 26 APIs. Not for file-by-file review (swiftui-pro) or single-screen wiring (swiftui-ui-patterns)."
+description: "SwiftUI architecture, state: @Observable, @State, @Bindable, @Environment, view splitting, ViewModifiers, .task, API migration, Writing Tools, Transferable, sharing. Use when structuring an app or owning state. Not for review (swiftui-pro) or visual design (hig-foundations)."
 metadata:
   source: multi-agent-pipeline
 ---
@@ -332,8 +332,7 @@ struct ForecastView: View {
 
 | API | What it does |
 |---|---|
-| `.scrollEdgeEffectStyle(.soft, for: .top)` | Soft fade where content meets a scroll edge |
-| `.backgroundExtensionEffect()` | Extends a mirrored, blurred copy of the view under the safe areas |
+| `.scrollEdgeEffectStyle(.soft, for: .top)`, `.backgroundExtensionEffect()` | Liquid Glass companions; see `swiftui-liquid-glass` |
 | `@Animatable` macro | Synthesises `animatableData` for a type; see `swiftui-animation` |
 | `TextEditor(text:)` with an `AttributedString` binding | Rich text editing |
 
@@ -350,19 +349,20 @@ struct ForecastView: View {
 
 ## 9. Following the HIG
 
-- Semantic colors (`Color.primary`, `.secondary`,
-  `Color(uiColor: .systemBackground)`) adapt to light and dark mode.
-- Text styles (`.title`, `.headline`, `.body`, `.caption`) scale with Dynamic
-  Type.
-- Empty and error states use `ContentUnavailableView`.
-- Leave `spacing:` off stacks. The default `nil` picks platform spacing; pass a
-  number only for a deliberate choice.
-- Adapt layout to `horizontalSizeClass`.
-- Give controls an `.accessibilityLabel`, and switch stack axis when
-  `dynamicTypeSize.isAccessibilitySize` is true.
+This skill stops at structure and state. Visual rules live elsewhere:
 
-Details, token scales and examples:
-[references/design-polish.md](references/design-polish.md).
+- Type, color, contrast, spacing and safe areas: `hig-foundations`.
+- Bars, tabs and toolbars: `hig-components-layout`.
+- Empty, error and loading states, onboarding, permission screens:
+  `hig-patterns`.
+- Haptics and Core Haptics: `ios-haptics`.
+- Liquid Glass: `swiftui-liquid-glass`.
+- Theming, matched transitions, placeholders and form focus as screen
+  recipes: `swiftui-ui-patterns`.
+
+Two structural habits still belong here: leave `spacing:` off stacks unless a
+value is deliberate, and keep text sizes and colors semantic so the view code
+does not fight Dynamic Type or dark mode.
 
 ## 10. Writing Tools (iOS 18+)
 
@@ -453,9 +453,6 @@ final class ReaderPreferences {
   the case for MV, when a view model is justified, environment versus init
   injection, testing, app shell wiring, dependency modifier, `ModelContainer`,
   enum sheets, deep links, closure-based clients.
-- [references/design-polish.md](references/design-polish.md): HIG layout,
-  typography and color, theming, haptics and Core Haptics, matched transitions,
-  loading placeholders, form focus.
 - [references/deprecated-migration.md](references/deprecated-migration.md):
   old API to current API, with the release each replacement needs.
 - [references/platform-and-sharing.md](references/platform-and-sharing.md):

package/pipeline/skills/shared/external/swiftui-ui-patterns/references/components-index.md

@@ -22,7 +22,7 @@ Use this file to find component and cross-cutting guidance. Each entry lists whe
 - Focus handling: `references/focus.md`  -  Use for chaining fields and keyboard focus management.
 - Searchable: `references/searchable.md`  -  Use for native search UI with scopes and async results.
 - Async images and media: `references/media.md`  -  Use for remote media, previews, and media viewers.
-- Haptics: `references/haptics.md`  -  Use for tactile feedback tied to key actions.
+- Haptics: the `ios-haptics` skill  -  Use for tactile feedback tied to key actions.
 - Matched transitions: `references/matched-transitions.md`  -  Use for smooth source-to-destination animations.
 - Deep links and URL routing: `references/deeplinks.md`  -  Use for in-app navigation from URLs.
 - Title menus: `references/title-menus.md`  -  Use for filter or context menus in the navigation title.