@mmerterden/multi-agent-pipeline 20.35.0 → 20.37.0

package/pipeline/skills/shared/external/core-nfc/references/code-examples.md

@@ -0,0 +1,98 @@
+# Core NFC Code Examples
+
+Full code samples for the SKILL.md sections that link here. The rules and the decision guidance stay in SKILL.md; each heading below matches the SKILL.md section the code belongs to.
+
+## Reading NDEF data
+
+```swift
+import CoreNFC
+
+final class BadgeReader: NSObject, NFCNDEFReaderSessionDelegate {
+    private var session: NFCNDEFReaderSession?
+
+    func scan() {
+        guard NFCNDEFReaderSession.readingAvailable else { return }
+        session = NFCNDEFReaderSession(
+            delegate: self,
+            queue: nil,
+            invalidateAfterFirstRead: false
+        )
+        session?.alertMessage = "Hold the top of your iPhone near the badge."
+        session?.begin()
+    }
+
+    func readerSessionDidBecomeActive(_ session: NFCNDEFReaderSession) {}
+
+    func readerSession(_ reader: NFCNDEFReaderSession, didDetectNDEFs found: [NFCNDEFMessage]) {
+        for message in found {
+            for record in message.records {
+                handle(record)
+            }
+        }
+    }
+
+    func readerSession(_ reader: NFCNDEFReaderSession, didInvalidateWithError error: any Error) {
+        if let nfcError = error as? NFCReaderError,
+           nfcError.code == .readerSessionInvalidationErrorFirstNDEFTagRead
+            || nfcError.code == .readerSessionInvalidationErrorUserCanceled {
+            // Normal end of a scan, not a failure.
+        } else {
+            report(error)
+        }
+        self.session = nil
+    }
+
+    private func handle(_ record: NFCNDEFPayload) {}
+    private func report(_ error: Error) {}
+}
+```
+
+## Native tag access
+
+```swift
+final class CardReader: NSObject, NFCTagReaderSessionDelegate {
+    private var session: NFCTagReaderSession?
+
+    func scan() {
+        guard NFCTagReaderSession.readingAvailable else { return }
+        session = NFCTagReaderSession(pollingOption: [.iso14443, .iso15693], delegate: self, queue: nil)
+        session?.alertMessage = "Hold your transit card near the phone."
+        session?.begin()
+    }
+
+    func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {}
+
+    func tagReaderSession(_ reader: NFCTagReaderSession, didDetect found: [NFCTag]) {
+        if found.count > 1 {
+            retryAfterMultipleTags(reader)
+            return
+        }
+        guard !found.isEmpty else {
+            reader.restartPolling()
+            return
+        }
+        nonisolated(unsafe) let reader = reader
+        nonisolated(unsafe) let tags = found
+        Task {
+            let tag = tags[0]
+            do {
+                try await reader.connect(to: tag)
+            } catch {
+                reader.invalidate(errorMessage: error.localizedDescription)
+                return
+            }
+            switch tag {
+            case .iso7816(let card): await select(card, in: reader)
+            case .miFare(let chip): await inspect(chip, in: reader)
+            case .iso15693(let label): await readBlocks(label, in: reader)
+            case .feliCa(let card): await readSystemCodes(card, in: reader)
+            @unknown default: reader.invalidate(errorMessage: "This tag type is not handled.")
+            }
+        }
+    }
+
+    func tagReaderSession(_ reader: NFCTagReaderSession, didInvalidateWithError error: any Error) {
+        session = nil
+    }
+}
+```

package/pipeline/skills/shared/external/coreml/SKILL.md

@@ -28,29 +28,8 @@ NaturalLanguage, compute plans, lifecycle, errors, tests) is in
 generates a Swift class with typed inputs and outputs. Use it whenever it
 exists.
 
-```swift
-import CoreML
-
-func makeDenoiser() throws -> PhotoDenoiser {
-    let settings = MLModelConfiguration()
-    settings.computeUnits = .all
-    return try PhotoDenoiser(configuration: settings)
-}
-```
-
 **From a URL.** For models that are downloaded or stored outside the bundle:
 
-```swift
-import CoreML
-
-func bundledModel(named name: String) throws -> MLModel {
-    guard let url = Bundle.main.url(forResource: name, withExtension: "mlmodelc") else {
-        throw CocoaError(.fileNoSuchFile)
-    }
-    return try MLModel(contentsOf: url, configuration: MLModelConfiguration())
-}
-```
-
 **Asynchronously.** `MLModel.load(contentsOf:configuration:)` (async, iOS 15+)
 keeps large models from stalling the main thread and is the preferred loader.
 
@@ -66,6 +45,8 @@ how server-delivered models become loadable. Two rules travel together:
 When reviewing runtime-loaded models, state both: the async compile API needs
 iOS 16, and its output must be cached.
 
+Code for this section: [Core ML code](references/coreml-code.md).
+
 ## Configuration and compute units
 
 `MLModelConfiguration` chooses hardware, GPU precision and model parameters.
@@ -93,34 +74,12 @@ Choose `.cpuOnly` only after profiling says so.
 
 ## Predictions
 
-**Generated class:**
-
-```swift
-import CoreML
-
-func tagScene(_ frame: CVPixelBuffer, with model: SceneTagger) throws -> (String, Double) {
-    let result = try model.prediction(input: SceneTaggerInput(image: frame))
-    return (result.classLabel, result.classLabelProbs[result.classLabel] ?? 0)
-}
-```
-
-`classLabel` is the winning label and `classLabelProbs` maps every label to
+With the generated class, `classLabel` is the winning label and `classLabelProbs` maps every label to
 its probability.
 
-**Dictionary provider**, for inputs only known at run time:
-
-```swift
-import CoreML
+A dictionary feature provider covers inputs only known at run time.
 
-func tagWithThreshold(_ frame: CVPixelBuffer, cutoff: Double, model: MLModel) async throws -> String? {
-    let inputs = try MLDictionaryFeatureProvider(dictionary: [
-        "image": MLFeatureValue(pixelBuffer: frame),
-        "threshold": MLFeatureValue(double: cutoff)
-    ])
-    let outputs = try await model.prediction(from: inputs)
-    return outputs.featureValue(for: "label")?.stringValue
-}
-```
+Code for this section: [Core ML code](references/coreml-code.md).
 
 ### Sync or async prediction
 
@@ -215,59 +174,21 @@ tensors.
 `MLMultiArray` is the exchange type for non-image inputs and outputs; generated
 classes use it for array features.
 
-```swift
-import CoreML
-
-func embeddingInput(tokens: Int, width: Int) throws -> MLMultiArray {
-    let grid = try MLMultiArray(shape: [1, NSNumber(value: tokens), NSNumber(value: width)], dataType: .float32)
-    grid[[0, 0, 0] as [NSNumber]] = 0.25
-    return grid
-}
-
-func firstValue(of grid: MLMultiArray) -> Float {
-    grid[[0, 0, 0] as [NSNumber]].floatValue
-}
-
-func packed(_ values: [Float]) -> MLMultiArray {
-    MLMultiArray(MLShapedArray<Float>(scalars: values, shape: [1, values.count]))
-}
-```
-
 The shape reads batch, sequence, features. Tokenized text and audio feature
 patterns are in the reference.
 
+Code for this section: [Core ML code](references/coreml-code.md).
+
 ## Image input
 
 Image models take a `CVPixelBuffer`. When Vision drives the model
 (`CoreMLRequest` or `VNCoreMLRequest`), conversion happens automatically; the
 manual path is only for direct `MLModel` predictions.
 
-```swift
-import CoreGraphics
-import CoreVideo
-
-func pixelBuffer(from picture: CGImage, side: Int) -> CVPixelBuffer? {
-    let options = [
-        kCVPixelBufferCGImageCompatibilityKey: true,
-        kCVPixelBufferCGBitmapContextCompatibilityKey: true
-    ] as CFDictionary
-    var buffer: CVPixelBuffer?
-    guard CVPixelBufferCreate(kCFAllocatorDefault, side, side, kCVPixelFormatType_32ARGB, options, &buffer) == kCVReturnSuccess,
-          let buffer else { return nil }
-    CVPixelBufferLockBaseAddress(buffer, [])
-    defer { CVPixelBufferUnlockBaseAddress(buffer, []) }
-    let context = CGContext(
-        data: CVPixelBufferGetBaseAddress(buffer), width: side, height: side,
-        bitsPerComponent: 8, bytesPerRow: CVPixelBufferGetBytesPerRow(buffer),
-        space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue
-    )
-    context?.draw(picture, in: CGRect(x: 0, y: 0, width: side, height: side))
-    return buffer
-}
-```
-
 Normalization and center-crop helpers are in the reference.
 
+Code for this section: [Core ML code](references/coreml-code.md).
+
 ## Chaining models
 
 When pre- or post-processing is its own model, call them in order:
@@ -292,64 +213,26 @@ each sub-model then runs on the compute unit that suits it.
 Vision takes care of resizing, cropping, normalization, color space and
 orientation.
 
-```swift
-import CoreML
-import Vision
-
-func dominantLabel(in photo: CGImage, model: MLModel) async throws -> (String, Float)? {
-    let request = CoreMLRequest(model: try CoreMLModelContainer(model: model))
-    let observations = try await request.perform(on: photo)
-    guard let top = observations.first as? ClassificationObservation else { return nil }
-    return (top.identifier, top.confidence)
-}
-```
-
-`CoreMLRequest` needs iOS 18. The legacy route for detection models:
-
-```swift
-import CoreML
-import Vision
-
-func legacyDetections(in frame: CVPixelBuffer, model: MLModel) throws -> [(String, Float, CGRect)] {
-    let request = VNCoreMLRequest(model: try VNCoreMLModel(for: model))
-    request.imageCropAndScaleOption = .scaleFill
-    try VNImageRequestHandler(cvPixelBuffer: frame).perform([request])
-    let objects = request.results as? [VNRecognizedObjectObservation] ?? []
-    return objects.compactMap { object in
-        guard let label = object.labels.first else { return nil }
-        return (label.identifier, label.confidence, object.boundingBox)
-    }
-}
-```
+`CoreMLRequest` needs iOS 18. Detection models also have a legacy route through
+`VNCoreMLRequest` with a `VNCoreMLModel`.
 
 `boundingBox` is normalized. Everything else about Vision (OCR, barcodes,
 documents) is in `vision-framework`.
 
+Code for this section: [Core ML code](references/coreml-code.md).
+
 ## Profiling
 
 `MLComputePlan` (iOS 17.4+) tells you, before any prediction, which device
-each operation prefers and how expensive it is:
-
-```swift
-import CoreML
-
-func opsOffAccelerators(modelURL: URL) async throws -> [String] {
-    let plan = try await MLComputePlan.load(contentsOf: modelURL, configuration: MLModelConfiguration())
-    guard case .program(let program) = plan.modelStructure,
-          let entry = program.functions["main"] else { return [] }
-    return entry.block.operations.compactMap { op in
-        guard let usage = plan.deviceUsage(for: op), case .cpu = usage.preferred else { return nil }
-        let cost = plan.estimatedCost(of: op)?.weight ?? 0
-        return "\(op.operatorName) cost \(cost)"
-    }
-}
-```
+each operation prefers and how expensive it is.
 
 The Instruments Core ML template shows load time, per-prediction latency with a
 per-operation breakdown, which device each operation ran on, and memory.
 Profile with Product > Profile, not under the debugger, or the numbers are
 not representative.
 
+Code for this section: [Core ML code](references/coreml-code.md).
+
 ## Deployment
 
 | Strategy | Strength | Cost |
@@ -447,6 +330,7 @@ Keep the returned request alive while the model is in use and call
 
 ## References
 
+- [Core ML code](references/coreml-code.md): open for the code behind loading a model, predictions, MLMultiArray, image input, Vision and profiling.
 - `references/coreml-swift-integration.md`
 - `apple-on-device-ai` for conversion and compression in Python
 - https://developer.apple.com/documentation/coreml

package/pipeline/skills/shared/external/coreml/references/coreml-code.md

@@ -0,0 +1,208 @@
+# Core ML code
+
+<!-- toc -->
+- [Loading a model](#loading-a-model)
+- [Predictions](#predictions)
+- [MLMultiArray](#mlmultiarray)
+- [Image input](#image-input)
+- [Through Vision](#through-vision)
+- [Profiling](#profiling)
+<!-- /toc -->
+
+Code for loading, predictions, MLMultiArray, image input, Vision requests and profiling. SKILL.md keeps the rules and review guidance.
+
+## Loading a model
+
+**Generated class.** Drop a `.mlmodel` or `.mlpackage` into a target and Xcode
+generates a Swift class with typed inputs and outputs. Use it whenever it
+exists.
+
+```swift
+import CoreML
+
+func makeDenoiser() throws -> PhotoDenoiser {
+    let settings = MLModelConfiguration()
+    settings.computeUnits = .all
+    return try PhotoDenoiser(configuration: settings)
+}
+```
+
+**From a URL.** For models that are downloaded or stored outside the bundle:
+
+```swift
+import CoreML
+
+func bundledModel(named name: String) throws -> MLModel {
+    guard let url = Bundle.main.url(forResource: name, withExtension: "mlmodelc") else {
+        throw CocoaError(.fileNoSuchFile)
+    }
+    return try MLModel(contentsOf: url, configuration: MLModelConfiguration())
+}
+```
+
+**Asynchronously.** `MLModel.load(contentsOf:configuration:)` (async, iOS 15+)
+keeps large models from stalling the main thread and is the preferred loader.
+
+**Compiling on device.** `MLModel.compileModel(at:)` (async form, iOS 16+)
+turns a `.mlmodel` or `.mlpackage` into a `.mlmodelc` on the device, which is
+how server-delivered models become loadable. Two rules travel together:
+
+1. Compile once per model version, never on every launch; recompiling at each
+   start is a bug.
+2. The returned URL points into a temporary location. Move the `.mlmodelc`
+   somewhere durable such as Application Support and reuse it.
+
+When reviewing runtime-loaded models, state both: the async compile API needs
+iOS 16, and its output must be cached.
+
+## Predictions
+
+**Generated class:**
+
+```swift
+import CoreML
+
+func tagScene(_ frame: CVPixelBuffer, with model: SceneTagger) throws -> (String, Double) {
+    let result = try model.prediction(input: SceneTaggerInput(image: frame))
+    return (result.classLabel, result.classLabelProbs[result.classLabel] ?? 0)
+}
+```
+
+`classLabel` is the winning label and `classLabelProbs` maps every label to
+its probability.
+
+**Dictionary provider**, for inputs only known at run time:
+
+```swift
+import CoreML
+
+func tagWithThreshold(_ frame: CVPixelBuffer, cutoff: Double, model: MLModel) async throws -> String? {
+    let inputs = try MLDictionaryFeatureProvider(dictionary: [
+        "image": MLFeatureValue(pixelBuffer: frame),
+        "threshold": MLFeatureValue(double: cutoff)
+    ])
+    let outputs = try await model.prediction(from: inputs)
+    return outputs.featureValue(for: "label")?.stringValue
+}
+```
+
+## MLMultiArray
+
+`MLMultiArray` is the exchange type for non-image inputs and outputs; generated
+classes use it for array features.
+
+```swift
+import CoreML
+
+func embeddingInput(tokens: Int, width: Int) throws -> MLMultiArray {
+    let grid = try MLMultiArray(shape: [1, NSNumber(value: tokens), NSNumber(value: width)], dataType: .float32)
+    grid[[0, 0, 0] as [NSNumber]] = 0.25
+    return grid
+}
+
+func firstValue(of grid: MLMultiArray) -> Float {
+    grid[[0, 0, 0] as [NSNumber]].floatValue
+}
+
+func packed(_ values: [Float]) -> MLMultiArray {
+    MLMultiArray(MLShapedArray<Float>(scalars: values, shape: [1, values.count]))
+}
+```
+
+The shape reads batch, sequence, features. Tokenized text and audio feature
+patterns are in the reference.
+
+## Image input
+
+Image models take a `CVPixelBuffer`. When Vision drives the model
+(`CoreMLRequest` or `VNCoreMLRequest`), conversion happens automatically; the
+manual path is only for direct `MLModel` predictions.
+
+```swift
+import CoreGraphics
+import CoreVideo
+
+func pixelBuffer(from picture: CGImage, side: Int) -> CVPixelBuffer? {
+    let options = [
+        kCVPixelBufferCGImageCompatibilityKey: true,
+        kCVPixelBufferCGBitmapContextCompatibilityKey: true
+    ] as CFDictionary
+    var buffer: CVPixelBuffer?
+    guard CVPixelBufferCreate(kCFAllocatorDefault, side, side, kCVPixelFormatType_32ARGB, options, &buffer) == kCVReturnSuccess,
+          let buffer else { return nil }
+    CVPixelBufferLockBaseAddress(buffer, [])
+    defer { CVPixelBufferUnlockBaseAddress(buffer, []) }
+    let context = CGContext(
+        data: CVPixelBufferGetBaseAddress(buffer), width: side, height: side,
+        bitsPerComponent: 8, bytesPerRow: CVPixelBufferGetBytesPerRow(buffer),
+        space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue
+    )
+    context?.draw(picture, in: CGRect(x: 0, y: 0, width: side, height: side))
+    return buffer
+}
+```
+
+Normalization and center-crop helpers are in the reference.
+
+## Through Vision
+
+Vision takes care of resizing, cropping, normalization, color space and
+orientation.
+
+```swift
+import CoreML
+import Vision
+
+func dominantLabel(in photo: CGImage, model: MLModel) async throws -> (String, Float)? {
+    let request = CoreMLRequest(model: try CoreMLModelContainer(model: model))
+    let observations = try await request.perform(on: photo)
+    guard let top = observations.first as? ClassificationObservation else { return nil }
+    return (top.identifier, top.confidence)
+}
+```
+
+`CoreMLRequest` needs iOS 18. The legacy route for detection models:
+
+```swift
+import CoreML
+import Vision
+
+func legacyDetections(in frame: CVPixelBuffer, model: MLModel) throws -> [(String, Float, CGRect)] {
+    let request = VNCoreMLRequest(model: try VNCoreMLModel(for: model))
+    request.imageCropAndScaleOption = .scaleFill
+    try VNImageRequestHandler(cvPixelBuffer: frame).perform([request])
+    let objects = request.results as? [VNRecognizedObjectObservation] ?? []
+    return objects.compactMap { object in
+        guard let label = object.labels.first else { return nil }
+        return (label.identifier, label.confidence, object.boundingBox)
+    }
+}
+```
+
+`boundingBox` is normalized. Everything else about Vision (OCR, barcodes,
+documents) is in `vision-framework`.
+
+## Profiling
+
+`MLComputePlan` (iOS 17.4+) tells you, before any prediction, which device
+each operation prefers and how expensive it is:
+
+```swift
+import CoreML
+
+func opsOffAccelerators(modelURL: URL) async throws -> [String] {
+    let plan = try await MLComputePlan.load(contentsOf: modelURL, configuration: MLModelConfiguration())
+    guard case .program(let program) = plan.modelStructure,
+          let entry = program.functions["main"] else { return [] }
+    return entry.block.operations.compactMap { op in
+        guard let usage = plan.deviceUsage(for: op), case .cpu = usage.preferred else { return nil }
+        let cost = plan.estimatedCost(of: op)?.weight ?? 0
+        return "\(op.operatorName) cost \(cost)"
+    }
+}
+```
+
+The Instruments Core ML template shows load time, per-prediction latency with a
+per-operation breakdown, which device each operation ran on, and memory.
+Profile with Product > Profile, not under the debugger, or the numbers are
+not representative.

package/pipeline/skills/shared/external/css-modern/SKILL.md

@@ -299,142 +299,15 @@ Cascade layers give explicit control over specificity order.
 
 ## CSS Custom Properties (Variables)
 
-```css
-:root {
-  /* Color system */
-  --color-brand: oklch(55% 0.25 265);
-  --color-brand-light: oklch(70% 0.2 265);
-  --color-brand-dark: oklch(40% 0.25 265);
-
-  --color-surface: #ffffff;
-  --color-surface-elevated: #f9fafb;
-  --color-text: #111827;
-  --color-text-muted: #6b7280;
-  --color-border: #e5e7eb;
-
-  /* Spacing scale */
-  --space-xs: 0.25rem;
-  --space-sm: 0.5rem;
-  --space-md: 1rem;
-  --space-lg: 1.5rem;
-  --space-xl: 2rem;
-  --space-2xl: 3rem;
-
-  /* Typography */
-  --font-sans: 'Inter', system-ui, sans-serif;
-  --font-mono: 'JetBrains Mono', monospace;
-
-  /* Transitions */
-  --transition-fast: 150ms ease;
-  --transition-normal: 250ms ease;
-  --transition-slow: 400ms ease;
-
-  /* Shadows */
-  --shadow-sm: 0 1px 2px rgb(0 0 0 / 0.05);
-  --shadow-md: 0 4px 6px rgb(0 0 0 / 0.1);
-  --shadow-lg: 0 10px 15px rgb(0 0 0 / 0.1);
-}
-
-/* Dark theme override */
-@media (prefers-color-scheme: dark) {
-  :root {
-    --color-surface: #111827;
-    --color-surface-elevated: #1f2937;
-    --color-text: #f9fafb;
-    --color-text-muted: #9ca3af;
-    --color-border: #374151;
-  }
-}
+Define the design tokens (colors, spacing scale, typography, transitions, shadows) once on `:root`, override them in a `prefers-color-scheme: dark` block, and consume them in components with `var()`.
 
-/* Component using tokens */
-.card {
-  background: var(--color-surface-elevated);
-  color: var(--color-text);
-  border: 1px solid var(--color-border);
-  border-radius: 0.75rem;
-  padding: var(--space-lg);
-  box-shadow: var(--shadow-sm);
-  transition: box-shadow var(--transition-normal);
-
-  &:hover {
-    box-shadow: var(--shadow-md);
-  }
-}
-```
+Code: [CSS Custom Properties (Variables)](references/code-examples.md#css-custom-properties-variables).
 
 ## Animations and Transitions
 
-```css
-/* View Transitions API */
-@view-transition {
-  navigation: auto;
-}
-
-.hero-image {
-  view-transition-name: hero;
-}
-
-::view-transition-old(hero) {
-  animation: fade-out 300ms ease;
-}
-
-::view-transition-new(hero) {
-  animation: fade-in 300ms ease;
-}
-
-/* Scroll-driven animations */
-@keyframes slide-in {
-  from { opacity: 0; transform: translateY(50px); }
-  to { opacity: 1; transform: translateY(0); }
-}
-
-.scroll-reveal {
-  animation: slide-in linear both;
-  animation-timeline: view();
-  animation-range: entry 0% entry 100%;
-}
-
-/* Transition with discrete properties */
-.dialog {
-  transition: opacity 300ms ease, display 300ms ease allow-discrete;
-  opacity: 0;
-  display: none;
-
-  &[open] {
-    opacity: 1;
-    display: block;
-
-    @starting-style {
-      opacity: 0;
-    }
-  }
-}
-
-/* Keyframe animation */
-@keyframes shimmer {
-  0% { background-position: -200% 0; }
-  100% { background-position: 200% 0; }
-}
-
-.skeleton {
-  background: linear-gradient(
-    90deg,
-    #f0f0f0 25%,
-    #e0e0e0 50%,
-    #f0f0f0 75%
-  );
-  background-size: 200% 100%;
-  animation: shimmer 1.5s infinite ease-in-out;
-}
+Use transitions for state changes (with `allow-discrete` when `display` animates), `@keyframes` for multi-step motion, and a `prefers-reduced-motion: reduce` block that turns motion off.
 
-/* Respect motion preferences */
-@media (prefers-reduced-motion: reduce) {
-  .scroll-reveal {
-    animation: none;
-    opacity: 1;
-  }
-}
-```
+Code: [Animations and Transitions](references/code-examples.md#animations-and-transitions).
 
 ## Do's
 
@@ -468,3 +341,7 @@ Cascade layers give explicit control over specificity order.
 | Grid item overflowing | Long word or fixed-width content | Add `min-width: 0` or `overflow: hidden` to grid item |
 | Subgrid not aligning | Missing `grid-row: span N` | Set span count to match number of sub-rows |
 | Custom property not applying | Scope issue or typo | Check spelling and ensure variable is defined in the right scope |
+
+## References
+
+- [Code examples](references/code-examples.md): open for the full code behind CSS Custom Properties (Variables), Animations and Transitions.