@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/skills/shared/external/swift-formatstyle/SKILL.md

@@ -0,0 +1,339 @@
+---
+name: swift-formatstyle
+description: "Format values for display using the FormatStyle protocol and its concrete types. Use when formatting numbers (integers, floating-point, decimals), currencies, percentages, dates, date ranges, relative dates, durations (Duration.TimeFormatStyle, Duration.UnitsFormatStyle), measurements, person names (PersonNameComponents.FormatStyle), byte counts (ByteCountFormatStyle), lists (ListFormatStyle), and URLs (URL.FormatStyle). Also covers creating custom FormatStyle conformances and replacing legacy Formatter subclasses. FormatStyle is available iOS 15+; Duration styles require iOS 16+."
+---
+
+# Swift FormatStyle
+
+Format values for human-readable display using the `FormatStyle` protocol
+and Foundation's concrete format styles. Replaces legacy `Formatter` subclasses
+with a type-safe, composable, cacheable API.
+
+Locale-aware display is an i18n concern even when the app is not adding new languages. For user-facing formatted output, always recommend previewing or testing representative locales such as `en_US`, `de_DE`, `ar_SA`, and `ja_JP`; check separators, numbering systems, calendars, currency and unit conventions, text direction, and layout-sensitive output. Keep this skill focused on `FormatStyle`, `ParseableFormatStyle`, parsing, and reusable formatter API design; route broader localization work such as String Catalogs, bundles, plurals, localized copy, and RTL layout review to `ios-localization`. Do not use "not adding languages" as the reason to skip `ios-localization`; locale-sensitive formatting can be a localization review issue without translation work.
+
+Docs: [FormatStyle](https://sosumi.ai/documentation/foundation/formatstyle)
+
+## Contents
+
+- [Quick Reference](#quick-reference)
+- [Numbers](#numbers)
+- [Currency](#currency)
+- [Percentages](#percentages)
+- [Dates](#dates)
+- [Durations](#durations)
+- [Measurements](#measurements)
+- [Person Names](#person-names)
+- [Lists](#lists)
+- [Byte Counts](#byte-counts)
+- [URLs](#urls)
+- [SwiftUI Integration](#swiftui-integration)
+- [Custom FormatStyle](#custom-formatstyle)
+- [Common Mistakes](#common-mistakes)
+- [Review Checklist](#review-checklist)
+
+## Quick Reference
+
+| Type | Style Access | Example |
+|------|-------------|---------|
+| `Int`, `Double` | `.number` | `42.formatted(.number.precision(.fractionLength(2)))` → `"42.00"` |
+| Currency | `.currency(code:)` | `29.99.formatted(.currency(code: "USD"))` → `"$29.99"` |
+| Percent | `.percent` | `0.85.formatted(.percent)` → `"85%"` |
+| `Date` | `.dateTime` | `Date.now.formatted(.dateTime.month().day().year())` |
+| Date range | `.interval` | `(date1..<date2).formatted(.interval)` |
+| Relative date | `.relative(presentation:unitsStyle:)` | `date.formatted(.relative(presentation: .named))` → `"yesterday"` |
+| `Duration` | `.time(pattern:)` | `Duration.seconds(3661).formatted(.time(pattern: .hourMinuteSecond))` → `"1:01:01"` |
+| `Duration` | `.units(allowed:width:)` | `Duration.seconds(90).formatted(.units(allowed: [.minutes, .seconds]))` → `"1 min, 30 sec"` |
+| `Measurement` | `.measurement(width:)` | `Measurement(value: 72, unit: UnitTemperature.fahrenheit).formatted(.measurement(width: .abbreviated))` |
+| `PersonNameComponents` | `.name(style:)` | `name.formatted(.name(style: .short))` → `"Tom"` |
+| `[String]` | `.list(type:width:)` | `["A","B","C"].formatted(.list(type: .and))` → `"A, B, and C"` |
+| Byte count | `.byteCount(style:)` | `Int64(1_048_576).formatted(.byteCount(style: .memory))` → `"1 MB"` |
+| `URL` | `.url` | `url.formatted(.url.scheme(.never).host().path())` |
+
+## Numbers
+
+```swift
+// Default locale-aware formatting
+let n = 1234567.formatted()  // "1,234,567" (en_US)
+
+// Precision
+1234.5.formatted(.number.precision(.fractionLength(0...2)))  // "1,234.5"
+1234.5.formatted(.number.precision(.significantDigits(3)))    // "1,230"
+
+// Rounding
+1234.formatted(.number.rounded(rule: .down, increment: 100)) // "1,200"
+
+// Grouping
+1234567.formatted(.number.grouping(.never))                   // "1234567"
+
+// Notation
+1_200_000.formatted(.number.notation(.compactName))           // "1.2M"
+42.formatted(.number.notation(.scientific))                    // "4.2E1"
+
+// Sign display
+(-42).formatted(.number.sign(strategy: .always()))            // "+42" / "-42"
+
+// Locale override
+42.formatted(.number.locale(Locale(identifier: "de_DE")))     // "42"
+```
+
+Docs: [IntegerFormatStyle](https://sosumi.ai/documentation/foundation/integerformatstyle),
+[FloatingPointFormatStyle](https://sosumi.ai/documentation/foundation/floatingpointformatstyle)
+
+## Currency
+
+```swift
+29.99.formatted(.currency(code: "USD"))   // "$29.99"
+29.99.formatted(.currency(code: "EUR"))   // "€29.99"
+29.99.formatted(.currency(code: "JPY"))   // "¥30"
+
+// Customize precision
+let style = FloatingPointFormatStyle<Double>.Currency(code: "USD")
+    .precision(.fractionLength(0))
+1234.56.formatted(style)  // "$1,235"
+```
+
+## Percentages
+
+```swift
+0.85.formatted(.percent)                                      // "85%"
+0.8567.formatted(.percent.precision(.fractionLength(1)))       // "85.7%"
+42.formatted(.percent)                                         // "42%"  (integer)
+```
+
+## Dates
+
+```swift
+let now = Date.now
+
+// Components
+now.formatted(.dateTime.year().month().day())           // "Apr 22, 2026"
+now.formatted(.dateTime.hour().minute())                // "4:30 PM"
+now.formatted(.dateTime.weekday(.wide).month(.wide).day()) // "Wednesday, April 22"
+
+// Predefined styles
+now.formatted(date: .long, time: .shortened)            // "April 22, 2026 at 4:30 PM"
+now.formatted(date: .abbreviated, time: .omitted)       // "Apr 22, 2026"
+
+// ISO 8601
+now.formatted(.iso8601)                                 // "2026-04-22T16:30:00Z"
+
+// Relative
+let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: .now)!
+yesterday.formatted(.relative(presentation: .named))    // "yesterday"
+yesterday.formatted(.relative(presentation: .numeric))  // "1 day ago"
+
+// Interval
+(date1..<date2).formatted(.interval.month().day().hour().minute())
+
+// Components (countdown-style)
+(date1..<date2).formatted(.components(style: .wide, fields: [.day, .hour]))
+// "2 days, 5 hours"
+```
+
+Docs: [Date.FormatStyle](https://sosumi.ai/documentation/foundation/date/formatstyle),
+[Date.RelativeFormatStyle](https://sosumi.ai/documentation/foundation/date/relativeformatstyle),
+[Date.IntervalFormatStyle](https://sosumi.ai/documentation/foundation/date/intervalformatstyle)
+
+### Anchored Relative Dates (iOS 18+)
+
+`Date.AnchoredRelativeFormatStyle` formats relative to a fixed anchor date
+rather than the current moment.
+
+Docs: [Date.AnchoredRelativeFormatStyle](https://sosumi.ai/documentation/foundation/date/anchoredrelativeformatstyle)
+
+## Durations
+
+`Duration` (iOS 16+) has two format styles:
+
+Docs: [Duration.TimeFormatStyle](https://sosumi.ai/documentation/swift/duration/timeformatstyle),
+[Duration.UnitsFormatStyle](https://sosumi.ai/documentation/swift/duration/unitsformatstyle)
+
+### TimeFormatStyle  -  compact separator-based
+
+```swift
+let d = Duration.seconds(3661)
+
+d.formatted(.time(pattern: .hourMinuteSecond))       // "1:01:01"
+d.formatted(.time(pattern: .hourMinute))             // "1:01"
+d.formatted(.time(pattern: .minuteSecond))           // "61:01"
+
+// Fractional seconds
+Duration.seconds(3.75).formatted(
+    .time(pattern: .minuteSecond(padMinuteToLength: 2, fractionalSecondsLength: 2))
+)  // "00:03.75"
+```
+
+### UnitsFormatStyle  -  labeled units
+
+```swift
+Duration.seconds(3661).formatted(
+    .units(allowed: [.hours, .minutes, .seconds], width: .abbreviated)
+)  // "1 hr, 1 min, 1 sec"
+
+Duration.seconds(90).formatted(
+    .units(allowed: [.minutes, .seconds], width: .wide)
+)  // "1 minute, 30 seconds"
+
+Duration.seconds(90).formatted(
+    .units(allowed: [.minutes, .seconds], width: .narrow)
+)  // "1m 30s"
+
+// Limit unit count
+Duration.seconds(3661).formatted(
+    .units(allowed: [.hours, .minutes, .seconds], width: .abbreviated, maximumUnitCount: 2)
+)  // "1 hr, 1 min"
+```
+
+## Measurements
+
+```swift
+let temp = Measurement(value: 72, unit: UnitTemperature.fahrenheit)
+temp.formatted(.measurement(width: .wide))        // "72 degrees Fahrenheit"
+temp.formatted(.measurement(width: .abbreviated))  // "72°F"
+temp.formatted(.measurement(width: .narrow))       // "72°"
+
+let dist = Measurement(value: 5, unit: UnitLength.kilometers)
+dist.formatted(.measurement(width: .abbreviated, usage: .road))  // "3.1 mi" (en_US)
+```
+
+Docs: [Measurement.FormatStyle](https://sosumi.ai/documentation/foundation/measurement/formatstyle)
+
+## Person Names
+
+```swift
+var name = PersonNameComponents()
+name.givenName = "Thomas"
+name.familyName = "Clark"
+name.middleName = "Louis"
+name.namePrefix = "Dr."
+name.nickname = "Tom"
+name.nameSuffix = "Esq."
+
+name.formatted(.name(style: .long))        // "Dr. Thomas Louis Clark Esq."
+name.formatted(.name(style: .medium))      // "Thomas Clark"
+name.formatted(.name(style: .short))       // "Tom"
+name.formatted(.name(style: .abbreviated)) // "TC"
+```
+
+Style resolution follows priority: script → user preferences → locale → developer setting.
+
+Docs: [PersonNameComponents.FormatStyle](https://sosumi.ai/documentation/foundation/personnamecomponents/formatstyle)
+
+## Lists
+
+```swift
+["Alice", "Bob", "Charlie"].formatted(.list(type: .and))
+// "Alice, Bob, and Charlie"
+
+["Alice", "Bob", "Charlie"].formatted(.list(type: .or))
+// "Alice, Bob, or Charlie"
+
+// With member formatting
+[1, 2, 3].formatted(.list(memberStyle: .number, type: .and))
+// "1, 2, and 3"
+
+// Narrow width
+["A", "B", "C"].formatted(.list(type: .and, width: .narrow))
+// "A, B, C"
+```
+
+Docs: [ListFormatStyle](https://sosumi.ai/documentation/foundation/listformatstyle)
+
+## Byte Counts
+
+```swift
+Int64(1_048_576).formatted(.byteCount(style: .memory))   // "1 MB"
+Int64(1_048_576).formatted(.byteCount(style: .file))      // "1 MB"
+Int64(1_048_576).formatted(.byteCount(style: .binary))    // "1 MiB"
+```
+
+Docs: [ByteCountFormatStyle](https://sosumi.ai/documentation/foundation/bytecountformatstyle)
+
+## URLs
+
+```swift
+let url = URL(string: "https://example.com/path?q=1")!
+url.formatted()
+// "https://example.com/path?q=1"
+
+url.formatted(.url.scheme(.never).host().path())
+// "example.com/path"
+
+url.formatted(.url.scheme(.always).host(.never).path())
+// "https:///path"
+```
+
+Docs: [URL.FormatStyle](https://sosumi.ai/documentation/foundation/url/formatstyle)
+
+## SwiftUI Integration
+
+`Text` accepts a `format:` parameter, keeping formatting out of the view model.
+
+```swift
+// Inline format style
+Text(price, format: .currency(code: "USD"))
+Text(date, format: .dateTime.month().day().year())
+Text(duration, format: .units(allowed: [.minutes, .seconds]))
+
+// Timer-style (live updating)
+Text(.now, style: .timer)
+Text(.now, style: .relative)
+Text(timerInterval: start...end)
+```
+
+**Prefer `Text(_:format:)` over string interpolation**  -  it allows SwiftUI to
+re-render only the formatted value and supports accessibility scaling.
+
+## Custom FormatStyle
+
+Conform to `FormatStyle` for domain-specific formatting. Conform to
+`ParseableFormatStyle` if you also need parsing.
+
+```swift
+struct AbbreviatedCountStyle: FormatStyle {
+    func format(_ value: Int) -> String {
+        switch value {
+        case ..<1_000:
+            return "\(value)"
+        case 1_000..<1_000_000:
+            return String(format: "%.1fK", Double(value) / 1_000)
+        default:
+            return String(format: "%.1fM", Double(value) / 1_000_000)
+        }
+    }
+}
+
+extension FormatStyle where Self == AbbreviatedCountStyle {
+    static var abbreviatedCount: AbbreviatedCountStyle { .init() }
+}
+
+// Usage
+let followers = 12_500
+Text(followers, format: .abbreviatedCount)  // "12.5K"
+```
+
+## Common Mistakes
+
+| Mistake | Fix |
+|---------|-----|
+| Using legacy `NumberFormatter` / `DateFormatter` in new code | Use `FormatStyle` (iOS 15+). Foundation caches format style instances automatically. |
+| String interpolation for formatted numbers in `Text` | Use `Text(value, format:)` for locale correctness and accessibility |
+| Hardcoding locale in format styles | Omit `.locale()` to inherit the user's current locale by default |
+| Using `.time(pattern:)` for labeled duration display | Use `.units(allowed:width:)` for "1 hr, 30 min" style output |
+| Creating `Formatter` instances in `body` or tight loops | FormatStyle instances are value types cached by Foundation; safe to create inline |
+| Formatting `Duration` with `DateComponentsFormatter` | Use `Duration.TimeFormatStyle` or `Duration.UnitsFormatStyle` directly |
+| Ignoring `usage:` parameter for measurements | Specify `.road`, `.asProvided`, etc. for locale-aware unit conversion |
+
+## Review Checklist
+
+- [ ] `FormatStyle` used instead of legacy `Formatter` subclasses for iOS 15+ targets
+- [ ] `Text(_:format:)` used instead of pre-formatting strings for SwiftUI text
+- [ ] No hardcoded locale unless explicitly needed (e.g., server communication)
+- [ ] Duration formatting uses `Duration.TimeFormatStyle` or `Duration.UnitsFormatStyle`
+- [ ] Currency codes are ISO 4217 strings, not hardcoded symbols
+- [ ] Measurement formatting includes `usage:` for user-facing display
+- [ ] Custom FormatStyle types conform to `Codable` + `Hashable` for caching
+
+## References
+
+- Apple docs: [FormatStyle](https://sosumi.ai/documentation/foundation/formatstyle) | [Date.FormatStyle](https://sosumi.ai/documentation/foundation/date/formatstyle) | [Duration.TimeFormatStyle](https://sosumi.ai/documentation/swift/duration/timeformatstyle)

package/pipeline/skills/shared/external/swift-language/SKILL.md

@@ -1,15 +1,12 @@
 ---
 name: swift-language
-description: "Apply modern Swift language patterns and idioms for non-concurrency, non-SwiftUI code. Covers if/switch expressions (Swift 5.9+), typed throws (Swift 6+), result builders, property wrappers, opaque and existential types (some vs any), guard patterns, Never type, Regex builders (Swift 5.7+), Codable best practices (CodingKeys, custom decoding, nested containers), modern collection APIs (count(where:), contains(where:), replacing()), FormatStyle (.formatted() on dates, numbers, measurements), and string interpolation patterns. Use when writing core Swift code involving generics, protocols, enums, closures, or modern language features."
+description: "Apply modern Swift language patterns and idioms for non-concurrency, non-SwiftUI code. Covers if/switch expressions (Swift 5.9+), typed throws (Swift 6+), result builders, property wrappers, opaque and existential types (some vs any), guard patterns, Never type, Regex builders (Swift 5.7+), basic Codable shaping (CodingKeys, custom decoding, nested containers), modern collection APIs (count(where:), contains(where:), replacing()), basic FormatStyle usage, and string interpolation patterns. Use when writing core Swift code involving generics, protocols, enums, closures, or modern language features; route deep Codable to swift-codable, detailed formatting/localization to swift-formatstyle, and API naming to swift-api-design-guidelines."
 ---
 
 # Swift Language Patterns
 
-Core Swift language features and modern syntax patterns targeting Swift 5.9+
-through Swift 6. Covers language constructs, type system features, Codable,
-string and collection APIs, and formatting. For concurrency (actors, async/await,
-Sendable), see the `swift-concurrency` skill. For SwiftUI views and state
-management, see `swiftui-patterns`.
+Core Swift language features and modern syntax patterns targeting Swift 6.3. Covers language constructs, type system features, basic Codable,
+string and collection APIs, basic formatting, C interop (`@c`), module disambiguation (`ModuleName::symbol`), and performance attributes (`@specialized`, `@inline(always)`). For `@c` corrections, enumerate invalid Swift-only signature types: `String`, `Array`, `UnsafeBufferPointer`, closures, and generic placeholders. Route deeper Codable/API decoding to `swift-codable`, detailed formatting/localization to `swift-formatstyle`, API naming to `swift-api-design-guidelines`, concurrency to `swift-concurrency`, and SwiftUI state/view work to `swiftui-patterns`.
 
 ## Contents
 
@@ -179,13 +176,13 @@ func makeCollection() -> some Collection<Int> {
 
 Use `some` for:
 - Return types when you want to hide implementation but preserve type identity.
-- Parameter types (Swift 5.9+): `func process(_ items: some Collection<Int>)` --
-  equivalent to a generic `<C: Collection<Int>>`.
+- Parameter types (Swift 5.7+): `some P` is shorthand for an unnamed generic
+  parameter such as `<T: P>`.
 
 ### `any Protocol` (Existential Type)
 
-An existential box that can hold any conforming type at runtime. Has overhead
-from dynamic dispatch and heap allocation.
+An existential box that can hold any conforming type at runtime. It uses dynamic
+dispatch and may allocate when the value does not fit in the inline buffer.
 
 ```swift
 func process(items: [any StringProtocol]) {
@@ -241,8 +238,12 @@ func processOrder(_ order: Order?) throws -> Receipt {
 
 ## Never Type
 
-`Never` indicates a function that never returns. It conforms to all protocols
-since Swift 5.5+ (bottom type).
+`Never` is an uninhabited type for code paths that never produce a value. It
+works as Swift's bottom type in expression contexts, but it does not implicitly
+conform to arbitrary protocols or satisfy a generic `T: SomeProtocol`
+constraint. When recommending `Result<T, Never>` or `throws(Never)`, explicitly
+state all three points: uninhabited, bottom-like, and no universal protocol
+conformance.
 
 ```swift
 // Function that terminates the program
@@ -252,13 +253,11 @@ func crashWithDiagnostics(_ message: String) -> Never {
     fatalError(message)
 }
 
-// Useful in generic contexts
 enum Result<Success, Failure: Error> {
     case success(Success)
     case failure(Failure)
 }
 // Result<String, Never> -- a result that can never fail
-// Result<Never, Error>  -- a result that can never succeed
 
 // Exhaustive switch: no default needed since Never has no cases
 func handle(_ result: Result<String, Never>) {
@@ -274,6 +273,7 @@ func handle(_ result: Result<String, Never>) {
 Swift 5.7+ Regex builder DSL provides compile-time checked, readable patterns.
 
 ```swift
+import Foundation
 import RegexBuilder
 
 // Parse "2024-03-15" into components
@@ -283,6 +283,7 @@ let dateRegex = Regex {
 
 if let match = "2024-03-15".firstMatch(of: dateRegex) {
     let (_, year, month, day) = match.output
+    _ = (year, month, day)
 }
 
 // TryCapture with transform
@@ -373,7 +374,7 @@ struct Record: Decodable {
 }
 ```
 
-See `references/swift-patterns-extended.md` for additional Codable patterns
+See [references/swift-patterns-extended.md](references/swift-patterns-extended.md) for additional Codable patterns
 (enums with associated values, date strategies, unkeyed containers).
 
 ## Modern Collection APIs
@@ -383,7 +384,7 @@ Prefer these modern APIs over manual loops:
 ```swift
 let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
 
-// count(where:) -- Swift 5.0+, use instead of .filter { }.count
+// count(where:) -- use instead of .filter { }.count
 let evenCount = numbers.count(where: { $0.isMultiple(of: 2) })
 
 // contains(where:) -- short-circuits on first match
@@ -453,7 +454,7 @@ let date = try Date("Mar 15, 2024", strategy: .dateTime.month().day().year())
 
 ## String Interpolation
 
-Extend `DefaultStringInterpolation` for domain-specific formatting. Use `"""` for multi-line strings (indentation is relative to the closing `"""`). See `references/swift-patterns-extended.md` for custom interpolation examples.
+Extend `DefaultStringInterpolation` for domain-specific formatting. Use `"""` for multi-line strings (indentation is relative to the closing `"""`). See [references/swift-patterns-extended.md](references/swift-patterns-extended.md) for custom interpolation examples.
 
 ## Common Mistakes
 
@@ -467,32 +468,30 @@ Extend `DefaultStringInterpolation` for domain-specific formatting. Use `"""` fo
    for optional or missing keys.
 5. **Nested if-let chains.** Use `guard let` for preconditions to keep the
    happy path at the top level.
-6. **String regex for simple operations.** Use `.replacing()` and
-   `.contains()` before reaching for Regex.
+6. **Invalid `@c` signatures.** Name valid C types and explicitly reject:
+   `String`, `Array`, `UnsafeBufferPointer`, closures, generic placeholders.
 7. **Ignoring typed throws.** When a function has a single, clear error type,
    typed throws give callers exhaustive switch without casting.
 8. **Overusing property wrappers.** A computed property is simpler when there
    is no reuse or projected value needed.
-9. **Building collections with `var` + `append` in a loop.** Prefer `map`,
-   `filter`, `compactMap`, or `reduce(into:)`.
-10. **Not using if/switch expressions.** When assigning from a condition, use
-    an expression instead of declaring `var` and mutating it.
+9. **Underspecifying `Never`.** For `Result<T, Never>` or `throws(Never)`, say:
+   uninhabited, bottom-like, and not arbitrary `T: P` protocol conformance.
+10. **Owning deep formatting/localization.** Use `swift-formatstyle` for detailed
+    formatting and `ios-localization` for market/localized-display QA.
 
 ## Review Checklist
 
-- [ ] `some` used over `any` where possible
-- [ ] `guard` used for preconditions, not nested `if let`
-- [ ] Collection APIs used instead of manual loops
+- [ ] `some` used for opaque returns and Swift 5.7+ generic-parameter shorthand
+- [ ] `guard` for preconditions; collection APIs instead of manual loops
 - [ ] `.formatted()` used instead of `DateFormatter`/`NumberFormatter`
-- [ ] Codable types use `CodingKeys` for API key mapping
-- [ ] `decodeIfPresent` with defaults for optional JSON fields
-- [ ] if/switch expressions used for simple conditional assignment
-- [ ] Property wrappers have clear reuse justification
+- [ ] Codable types use `CodingKeys` for API mapping; `decodeIfPresent` with defaults for optional fields
+- [ ] if/switch expressions for conditional assignment; property wrappers have clear reuse justification
 - [ ] Regex builder used for complex patterns (literal OK for simple ones)
-- [ ] String interpolation is clean -- no unnecessary `String(describing:)`
 - [ ] Typed throws used when callers benefit from exhaustive error handling
-- [ ] `Never` used appropriately in generic contexts
-
+- [ ] `@c` corrections enumerate rejected Swift-only types by name
+- [ ] `Never` guidance says uninhabited, bottom-like, and not arbitrary `T: P` protocol conformance
+- [ ] deep Codable, formatting/localization, naming, concurrency, and SwiftUI work routed to sibling skills
 ## References
 
-- Extended patterns and Codable examples: `references/swift-patterns-extended.md`
+- Extended patterns and Codable examples: [references/swift-patterns-extended.md](references/swift-patterns-extended.md)
+- Attributes and C interop: [references/swift-attributes-interop.md](references/swift-attributes-interop.md)

package/pipeline/skills/shared/external/swift-language/evals/evals.json

@@ -0,0 +1,47 @@
+{
+  "skill_name": "swift-language",
+  "evals": [
+    {
+      "id": 0,
+      "name": "modern-language-refactor",
+      "prompt": "Review and modernize this Swift helper without changing behavior. Use current Swift language idioms where they help, but keep the answer concise.\n\n```swift\nenum Priority { case low, normal, high }\nenum ValidationError: Error { case empty, tooLong }\n\nfunc validateTitle(_ title: String) throws -> String {\n    if title.isEmpty {\n        throw ValidationError.empty\n    }\n    if title.count > 80 {\n        throw ValidationError.tooLong\n    }\n    return title.trimmingCharacters(in: .whitespacesAndNewlines)\n}\n\nfunc iconName(priority: Priority) -> String {\n    var name = \"circle\"\n    switch priority {\n    case .low:\n        name = \"arrow.down.circle\"\n    case .normal:\n        name = \"circle\"\n    case .high:\n        name = \"exclamationmark.circle\"\n    }\n    return name\n}\n\nfunc summarize(_ tags: [String]) -> String {\n    var urgentCount = 0\n    for tag in tags {\n        if tag == \"urgent\" { urgentCount += 1 }\n    }\n    return \"urgent: \\(urgentCount)\"\n}\n```",
+      "expected_output": "A concise modernization that uses guard preconditions, typed throws for the single validation error domain, switch expressions for conditional return, collection APIs such as count(where:), and explains why each change is appropriate.",
+      "files": [],
+      "assertions": [
+        "Uses `throws(ValidationError)` or explicitly recommends typed throws for the single validation error domain.",
+        "Uses `guard` for validation preconditions in `validateTitle(_:)`.",
+        "Rewrites `iconName(priority:)` with a `switch` expression or equivalent single-expression return without a mutable temporary variable.",
+        "Uses `count(where:)` rather than a manual loop for counting urgent tags.",
+        "Keeps the answer focused on Swift language idioms and does not expand into SwiftUI, concurrency, or lint configuration."
+      ]
+    },
+    {
+      "id": 1,
+      "name": "swift63-interop-attributes",
+      "prompt": "Correct this Swift 6.3 interoperability/performance note for a team wiki. The draft says: `@c func export(_ bytes: UnsafeBufferPointer<UInt8>) -> Int32` is valid C export syntax, `@specialize` is the official function-specialization attribute, `@inline(always)` is just a hint, and module selectors are written `ModuleName.symbol`.\n\nGive a corrected note with minimal Swift examples.",
+      "expected_output": "A source-grounded correction that uses a C-compatible @c signature, names @specialized as the official explicit-specialization attribute, treats @inline(always) as a guaranteed inlining request that can fail when impossible, and uses ModuleName::symbol module selectors.",
+      "files": [],
+      "assertions": [
+        "Rejects `UnsafeBufferPointer<UInt8>` in an `@c` exported function signature because it is a Swift struct, not a C-representable parameter.",
+        "Shows an `@c` example using C-compatible pointer and scalar types, optionally with a custom C symbol name.",
+        "Uses `@specialized`, not `@specialize`, for explicit specialization.",
+        "States that Swift 6.3 `@inline(always)` guarantees inlining for direct calls and can produce an error when inlining is impossible.",
+        "Uses `ModuleName::symbol` syntax for module selectors."
+      ]
+    },
+    {
+      "id": 2,
+      "name": "sibling-boundary-routing",
+      "prompt": "I have three cleanup requests in an iOS package: build full Codable API models with snake_case key strategies and date decoding, design locale-sensitive currency/date/list formatting for several markets, and decide whether a reusable Swift helper should use `some`, `any`, or `Never`. Which parts should the Swift language skill own, and which should be routed to sibling skills? Include only minimal examples.",
+      "expected_output": "A boundary-aware routing answer that keeps swift-language focused on core type-system features such as some/any/Never, routes deep Codable/API decoding to swift-codable, routes detailed formatting and localization-sensitive display work to swift-formatstyle or ios-localization, and avoids implementing the sibling domains.",
+      "files": [],
+      "assertions": [
+        "Says swift-language owns the core type-system/language decision around `some`, `any`, and `Never`.",
+        "Correctly explains that `Never` is uninhabited/bottom-type-like in expression contexts but does not implicitly conform to arbitrary protocols.",
+        "Routes full Codable API model design, key strategies, and date decoding to `swift-codable`.",
+        "Routes detailed FormatStyle and locale-sensitive display work to `swift-formatstyle` and mentions localization review when appropriate.",
+        "Does not provide a full Codable model suite or full formatting/localization implementation."
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/swift-language/references/swift-attributes-interop.md

@@ -0,0 +1,97 @@
+# Swift Attributes and C Interoperability
+
+Attributes and interoperability features for Swift. Covers C-calling-convention export, module disambiguation, performance annotations, and symbol visibility control.
+
+## Contents
+
+- [C Interoperability  -  `@c` Attribute](#c-interoperability--c-attribute)
+- [Module Selectors](#module-selectors)
+- [Performance Annotations](#performance-annotations)
+- [Symbol Visibility and Layout](#symbol-visibility-and-layout)
+
+## C Interoperability  -  `@c` Attribute
+
+The `@c` attribute (SE-0495) marks a Swift function for direct C-calling-convention export. The function becomes callable from C, C++, and Objective-C without bridging headers or `@_cdecl`.
+
+```swift
+@c(MyLib_processBuffer)
+public func processBuffer(_ buffer: UnsafePointer<UInt8>?, _ count: Int32) -> Int32 {
+    guard let buffer else { return 0 }
+    return buffer.pointee == 0 ? 0 : count
+}
+```
+
+**Requirements:**
+- Parameters and return types must be C-compatible (primitives, pointers, tuples of C-compatible types)
+- No Swift-only types (`String`, `Array`, `UnsafeBufferPointer`, closures, generic placeholders, etc.) in the signature
+- The function must be a module-level free function (not a method)
+- Use `@c(CustomName)` when the C symbol should differ from the Swift function name
+
+## Module Selectors
+
+SE-0491 adds `ModuleName::symbolName` syntax to disambiguate identically named symbols from different modules without `import` aliasing.
+
+```swift
+import NetworkingA
+import NetworkingB
+
+// Both modules export a top-level `configure()` function
+func setup() {
+    NetworkingA::configure()
+    NetworkingB::configure()
+}
+
+// Works with types too
+let client: NetworkingA::Client = .init()
+```
+
+## Performance Annotations
+
+### `@specialized`
+
+SE-0460 makes `@specialized` an official attribute (previously underscored as `@_specialize`). Forces the compiler to emit a specialized version of a generic function for specific concrete types.
+
+```swift
+@specialized(where T == Int)
+@specialized(where T == Double)
+func sum<T: Numeric>(_ values: [T]) -> T {
+    values.reduce(.zero, +)
+}
+```
+
+### `@inline(always)` Guarantee
+
+SE-0496 guarantees `@inline(always)` will inline the function at every call site. Previously it was a hint the compiler could ignore. A compilation error is now emitted if inlining is impossible (e.g., recursive calls).
+
+```swift
+@inline(always)
+func fastPath(_ x: Int) -> Int {
+    x &+ 1  // Guaranteed to be inlined at every call site
+}
+```
+
+## Symbol Visibility and Layout
+
+### `@export`
+
+SE-0497 gives explicit control over symbol visibility and definition availability:
+
+- `@export(interface)`  -  ensures a callable symbol exists in the binary but hides the definition from clients (no inlining/specialization by external callers). Replaces `@_neverEmitIntoClient`.
+- `@export(implementation)`  -  makes the definition available for inlining/specialization but does not guarantee a callable symbol. Replaces `@_alwaysEmitIntoClient`.
+
+```swift
+@export(interface)
+public func stableAPI() -> Int {
+    // Callable symbol guaranteed; definition hidden from clients
+    return computeValue()
+}
+```
+
+### `@section` and `@used`
+
+SE-0492 places global variables into named binary sections and prevents dead-stripping. Primarily for Embedded Swift and systems programming.
+
+```swift
+@section(".mydata") @used
+var configFlag: Int32 = 1
+```