@mmerterden/multi-agent-pipeline 20.36.0 → 20.37.1

package/pipeline/skills/shared/external/ios-networking/references/code-examples.md

@@ -0,0 +1,67 @@
+# iOS Networking 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.
+
+## Protocol-based client
+
+```swift
+protocol APIClientProtocol: Sendable {
+    func fetch<Reply: Decodable & Sendable>(_ endpoint: Endpoint, as kind: Reply.Type) async throws -> Reply
+    func send<Reply: Decodable & Sendable>(_ endpoint: Endpoint, json payload: some Encodable & Sendable,
+                                           as kind: Reply.Type) async throws -> Reply
+    func perform(_ endpoint: Endpoint) async throws
+    func upload<Reply: Decodable & Sendable>(_ endpoint: Endpoint, bytes: Data,
+                                             as kind: Reply.Type) async throws -> Reply
+}
+
+struct Endpoint: Sendable {
+    enum HTTPMethod: String, Sendable { case get, post, put, patch, delete }
+
+    var path: String
+    var method: HTTPMethod = .get
+    var queryItems: [URLQueryItem] = []
+    var headers: [String: String] = [:]
+    var body: Data? = nil
+    var cachePolicy: URLRequest.CachePolicy = .useProtocolCachePolicy
+    var timeoutInterval: TimeInterval = 30
+
+    func urlRequest(relativeTo baseURL: URL) throws -> URLRequest {
+        guard var parts = URLComponents(url: baseURL.appending(path: path),
+                                        resolvingAgainstBaseURL: true) else {
+            throw NetworkError.invalidURL
+        }
+        if !queryItems.isEmpty { parts.queryItems = queryItems }
+        guard let url = parts.url else { throw NetworkError.invalidURL }
+        var request = URLRequest(url: url, cachePolicy: cachePolicy, timeoutInterval: timeoutInterval)
+        request.httpMethod = method.rawValue.uppercased()
+        request.httpBody = body
+        request.allHTTPHeaderFields = headers
+        return request
+    }
+}
+```
+
+## Retry with exponential backoff
+
+```swift
+func withRetry<T: Sendable>(
+    maxAttempts: Int = 3,
+    initialDelay: Duration = .seconds(1),
+    maxDelay: Duration = .seconds(30),
+    shouldRetry: @Sendable (any Error) -> Bool = isTransient,
+    operation: @Sendable () async throws -> T
+) async throws -> T {
+    precondition(maxAttempts > 0, "maxAttempts must be at least 1")
+    for attempt in 0..<maxAttempts {
+        try Task.checkCancellation()
+        do {
+            return try await operation()
+        } catch {
+            guard attempt < maxAttempts - 1, shouldRetry(error) else { throw error }
+            let capped = min(initialDelay * (1 << attempt), maxDelay)
+            try await Task.sleep(for: capped + capped * Double.random(in: 0...0.1))
+        }
+    }
+    preconditionFailure("the last attempt always returns or throws")
+}
+```

package/pipeline/skills/shared/external/ios-security/SKILL.md

@@ -32,34 +32,9 @@ passwords, tokens, API keys, or secrets in UserDefaults, files, or Core Data.
 
 ### Storing Credentials
 
-```swift
-func saveToKeychain(account: String, data: Data, service: String) throws {
-    let query: [String: Any] = [
-        kSecClass as String: kSecClassGenericPassword,
-        kSecAttrAccount as String: account,
-        kSecAttrService as String: service,
-        kSecValueData as String: data,
-        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
-    ]
+Save with `SecItemAdd` and an explicit accessibility class; when the item already exists (`errSecDuplicateItem`), update it with `SecItemUpdate` instead of failing.
 
-    let status = SecItemAdd(query as CFDictionary, nil)
-
-    if status == errSecDuplicateItem {
-        let updateQuery: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrAccount as String: account,
-            kSecAttrService as String: service
-        ]
-        let updates: [String: Any] = [kSecValueData as String: data]
-        let updateStatus = SecItemUpdate(updateQuery as CFDictionary, updates as CFDictionary)
-        guard updateStatus == errSecSuccess else {
-            throw KeychainError.updateFailed(updateStatus)
-        }
-    } else if status != errSecSuccess {
-        throw KeychainError.saveFailed(status)
-    }
-}
-```
+Code: [Storing Credentials](references/code-examples.md#storing-credentials).
 
 ### Reading Credentials
 
@@ -364,43 +339,7 @@ Pin certificates for sensitive API connections to prevent MITM attacks.
 
 ### URLSession Delegate Pinning
 
-```swift
-import CryptoKit
-
-class PinnedSessionDelegate: NSObject, URLSessionDelegate {
-    // SHA-256 hash of the certificate's Subject Public Key Info
-    private let pinnedHashes: Set<String> = [
-        "base64EncodedSHA256HashOfSPKI=="
-    ]
-
-    func urlSession(
-        _ session: URLSession,
-        didReceive challenge: URLAuthenticationChallenge
-    ) async -> (URLSession.AuthChallengeDisposition, URLCredential?) {
-        guard let trust = challenge.protectionSpace.serverTrust,
-              let chain = SecTrustCopyCertificateChain(trust) as? [SecCertificate],
-              let certificate = chain.first else {
-            return (.cancelAuthenticationChallenge, nil)
-        }
-
-        guard let publicKey = SecCertificateCopyKey(certificate),
-              let publicKeyData = SecKeyCopyExternalRepresentation(
-                  publicKey, nil
-              ) as Data? else {
-            return (.cancelAuthenticationChallenge, nil)
-        }
-
-        let hash = SHA256.hash(data: publicKeyData)
-        let hashString = Data(hash).base64EncodedString()
-
-        if pinnedHashes.contains(hashString) {
-            return (.useCredential, URLCredential(trust: trust))
-        }
-
-        return (.cancelAuthenticationChallenge, nil)
-    }
-}
-```
+Code: [URLSession Delegate Pinning](references/code-examples.md#urlsession-delegate-pinning).
 
 Rules:
 - Pin the public key hash, not the certificate. Certificates rotate; public keys are more stable.
@@ -495,4 +434,5 @@ compliance checklists, see `references/app-review-guidelines.md`.
 - Privacy manifest guide: `references/privacy-manifest.md`
 - App Review security guidelines: `references/app-review-guidelines.md`
 - File storage directory guide and protection: `references/file-storage-patterns.md`
+- [Code examples](references/code-examples.md): open for the full code behind Storing Credentials, URLSession Delegate Pinning.
 

package/pipeline/skills/shared/external/ios-security/references/code-examples.md

@@ -0,0 +1,74 @@
+# iOS Security 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.
+
+## Storing Credentials
+
+```swift
+func saveToKeychain(account: String, data: Data, service: String) throws {
+    let query: [String: Any] = [
+        kSecClass as String: kSecClassGenericPassword,
+        kSecAttrAccount as String: account,
+        kSecAttrService as String: service,
+        kSecValueData as String: data,
+        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+    ]
+
+    let status = SecItemAdd(query as CFDictionary, nil)
+
+    if status == errSecDuplicateItem {
+        let updateQuery: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: account,
+            kSecAttrService as String: service
+        ]
+        let updates: [String: Any] = [kSecValueData as String: data]
+        let updateStatus = SecItemUpdate(updateQuery as CFDictionary, updates as CFDictionary)
+        guard updateStatus == errSecSuccess else {
+            throw KeychainError.updateFailed(updateStatus)
+        }
+    } else if status != errSecSuccess {
+        throw KeychainError.saveFailed(status)
+    }
+}
+```
+
+## URLSession Delegate Pinning
+
+```swift
+import CryptoKit
+
+class PinnedSessionDelegate: NSObject, URLSessionDelegate {
+    // SHA-256 hash of the certificate's Subject Public Key Info
+    private let pinnedHashes: Set<String> = [
+        "base64EncodedSHA256HashOfSPKI=="
+    ]
+
+    func urlSession(
+        _ session: URLSession,
+        didReceive challenge: URLAuthenticationChallenge
+    ) async -> (URLSession.AuthChallengeDisposition, URLCredential?) {
+        guard let trust = challenge.protectionSpace.serverTrust,
+              let chain = SecTrustCopyCertificateChain(trust) as? [SecCertificate],
+              let certificate = chain.first else {
+            return (.cancelAuthenticationChallenge, nil)
+        }
+
+        guard let publicKey = SecCertificateCopyKey(certificate),
+              let publicKeyData = SecKeyCopyExternalRepresentation(
+                  publicKey, nil
+              ) as Data? else {
+            return (.cancelAuthenticationChallenge, nil)
+        }
+
+        let hash = SHA256.hash(data: publicKeyData)
+        let hashString = Data(hash).base64EncodedString()
+
+        if pinnedHashes.contains(hashString) {
+            return (.useCredential, URLCredential(trust: trust))
+        }
+
+        return (.cancelAuthenticationChallenge, nil)
+    }
+}
+```

package/pipeline/skills/shared/external/live-activities/SKILL.md

@@ -62,34 +62,7 @@ Two layers, with different lifetimes:
 - `ContentState` carries whatever changes. The entire value is encoded on
   every update and in every push, so keep it lean.
 
-```swift
-import ActivityKit
-
-struct ChargingAttributes: ActivityAttributes {
-    struct ContentState: Codable, Hashable {
-        var batteryPercent: Int
-        var finishWindow: ClosedRange<Date>
-        var phase: ChargePhase
-    }
-
-    var stationName: String
-    var connectorLabel: String
-}
-
-enum ChargePhase: String, Codable, Hashable, CaseIterable {
-    case queued, connecting, charging, balancing, complete
-
-    var symbolName: String {
-        switch self {
-        case .queued: "hourglass"
-        case .connecting: "powerplug"
-        case .charging: "bolt.car"
-        case .balancing: "slider.horizontal.3"
-        case .complete: "checkmark.circle.fill"
-        }
-    }
-}
-```
+Code: [Modelling the data](references/code-examples.md#modelling-the-data).
 
 ### Stale date
 
@@ -114,25 +87,7 @@ let snapshot = ActivityContent(
 `pushType: .token` when a server should be able to update it. The
 `ActivityContent` form of `request` is iOS 16.2+.
 
-```swift
-func beginCharging(at station: String) {
-    let attributes = ChargingAttributes(stationName: station, connectorLabel: "B2")
-    let window = Date.now...Date.now.addingTimeInterval(30 * 60)
-    let initial = ChargingAttributes.ContentState(
-        batteryPercent: 18, finishWindow: window, phase: .connecting
-    )
-    do {
-        let activity = try Activity.request(
-            attributes: attributes,
-            content: ActivityContent(state: initial, staleDate: nil, relevanceScore: 75),
-            pushType: .token
-        )
-        sessionStore.remember(activity.id)
-    } catch {
-        logger.error("Live Activity refused: \(error.localizedDescription)")
-    }
-}
-```
+Code: [Start](references/code-examples.md#start).
 
 ### Update
 
@@ -198,49 +153,7 @@ The Lock Screen is the surface that always exists: every device on iOS 16.1 or
 later shows Live Activities there. Lay it out first, then squeeze it into the
 Dynamic Island.
 
-```swift
-import SwiftUI
-import WidgetKit
-
-struct ChargingLiveActivity: Widget {
-    var body: some WidgetConfiguration {
-        ActivityConfiguration(for: ChargingAttributes.self) { context in
-            HStack(spacing: 12) {
-                Image(systemName: context.state.phase.symbolName)
-                VStack(alignment: .leading) {
-                    Text(context.attributes.stationName).font(.headline)
-                    Text("\(context.state.batteryPercent)%")
-                }
-                Spacer()
-                if context.isStale {
-                    Label("Refreshing", systemImage: "arrow.trianglehead.2.clockwise")
-                        .foregroundStyle(.secondary)
-                } else {
-                    Text(timerInterval: context.state.finishWindow, countsDown: true)
-                        .monospacedDigit()
-                }
-            }
-            .padding()
-        } dynamicIsland: { context in
-            DynamicIsland {
-                DynamicIslandExpandedRegion(.center) {
-                    Text(context.attributes.stationName)
-                }
-                DynamicIslandExpandedRegion(.trailing) {
-                    Text("\(context.state.batteryPercent)%")
-                }
-            } compactLeading: {
-                Image(systemName: "bolt.car")
-            } compactTrailing: {
-                Text(timerInterval: context.state.finishWindow, countsDown: true)
-                    .monospacedDigit()
-            } minimal: {
-                Image(systemName: "bolt.car")
-            }
-        }
-    }
-}
-```
+Code: [Lock Screen](references/code-examples.md#lock-screen).
 
 Static values come from `context.attributes`; changing values from
 `context.state`.
@@ -447,3 +360,4 @@ update or end activities; they cannot start one. They are addressed with
   attributes model, start/update/end variants, server payloads and headers, channel pushes, concurrent activities, state and token observation,
   authorization, errors, background behaviour, testing, Info.plist keys and
   documentation links.
+- [Code examples](references/code-examples.md): open for the full code behind Modelling the data, Start, Lock Screen.

package/pipeline/skills/shared/external/live-activities/references/code-examples.md

@@ -0,0 +1,108 @@
+# Live Activities Code Examples
+
+<!-- toc -->
+- [Modelling the data](#modelling-the-data)
+- [Start](#start)
+- [Lock Screen](#lock-screen)
+<!-- /toc -->
+
+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.
+
+## Modelling the data
+
+```swift
+import ActivityKit
+
+struct ChargingAttributes: ActivityAttributes {
+    struct ContentState: Codable, Hashable {
+        var batteryPercent: Int
+        var finishWindow: ClosedRange<Date>
+        var phase: ChargePhase
+    }
+
+    var stationName: String
+    var connectorLabel: String
+}
+
+enum ChargePhase: String, Codable, Hashable, CaseIterable {
+    case queued, connecting, charging, balancing, complete
+
+    var symbolName: String {
+        switch self {
+        case .queued: "hourglass"
+        case .connecting: "powerplug"
+        case .charging: "bolt.car"
+        case .balancing: "slider.horizontal.3"
+        case .complete: "checkmark.circle.fill"
+        }
+    }
+}
+```
+
+## Start
+
+```swift
+func beginCharging(at station: String) {
+    let attributes = ChargingAttributes(stationName: station, connectorLabel: "B2")
+    let window = Date.now...Date.now.addingTimeInterval(30 * 60)
+    let initial = ChargingAttributes.ContentState(
+        batteryPercent: 18, finishWindow: window, phase: .connecting
+    )
+    do {
+        let activity = try Activity.request(
+            attributes: attributes,
+            content: ActivityContent(state: initial, staleDate: nil, relevanceScore: 75),
+            pushType: .token
+        )
+        sessionStore.remember(activity.id)
+    } catch {
+        logger.error("Live Activity refused: \(error.localizedDescription)")
+    }
+}
+```
+
+## Lock Screen
+
+```swift
+import SwiftUI
+import WidgetKit
+
+struct ChargingLiveActivity: Widget {
+    var body: some WidgetConfiguration {
+        ActivityConfiguration(for: ChargingAttributes.self) { context in
+            HStack(spacing: 12) {
+                Image(systemName: context.state.phase.symbolName)
+                VStack(alignment: .leading) {
+                    Text(context.attributes.stationName).font(.headline)
+                    Text("\(context.state.batteryPercent)%")
+                }
+                Spacer()
+                if context.isStale {
+                    Label("Refreshing", systemImage: "arrow.trianglehead.2.clockwise")
+                        .foregroundStyle(.secondary)
+                } else {
+                    Text(timerInterval: context.state.finishWindow, countsDown: true)
+                        .monospacedDigit()
+                }
+            }
+            .padding()
+        } dynamicIsland: { context in
+            DynamicIsland {
+                DynamicIslandExpandedRegion(.center) {
+                    Text(context.attributes.stationName)
+                }
+                DynamicIslandExpandedRegion(.trailing) {
+                    Text("\(context.state.batteryPercent)%")
+                }
+            } compactLeading: {
+                Image(systemName: "bolt.car")
+            } compactTrailing: {
+                Text(timerInterval: context.state.finishWindow, countsDown: true)
+                    .monospacedDigit()
+            } minimal: {
+                Image(systemName: "bolt.car")
+            }
+        }
+    }
+}
+```

package/pipeline/skills/shared/external/localization-reuse-map/SKILL.md

@@ -25,30 +25,15 @@ It is not a key-minting tool: new keys and their values belong to the resource-a
 
 ## Project settings
 
-Nothing company-specific is built in. Establish these once per project (read them from the project's docs or ask), then reuse them for every screen:
-
-| Setting | What it is | Example |
-|---|---|---|
-| Specs repo + design export | Screen frames, `components-used.md`, `screenshot.png`, `tree.json` | `design-export/<project>/screens/<slug>/` |
-| Resources root | Suggested new values and the component registry | `resources/Localization/Suggested/<Key>.json` |
-| Legacy label endpoint | For refreshing the legacy snapshot | `--endpoint` + `--headers-file` |
-| Legacy key prefix | Display-only prefix the backend stores | mapping `legacyKeyPrefix`, e.g. `App-` |
-| Web i18n convention | For legacy and/or new web apps | `t('key')` / `$t('key')`, keys in `locales/<lang>.json` |
-| Confluence target | Base URL, space, parent page | `CONFLUENCE_BASE_URL` / `CONFLUENCE_SPACE` / `CONFLUENCE_PARENT` |
-| CMS taxonomy | Property Group / Module buckets in the spreadsheet | `--taxonomy cms-taxonomy.json` |
-| Document language | Headings, legend and labels | `--ui-lang en` (default) or `tr` |
-
-Secrets live only in a keychain item or a `--headers-file`. They never go into the mapping, the taxonomy file, the docs or a command line.
-
-At the start, ask the user only for what is still unknown: where the implemented screen lives, the Figma file key and node-ids (or a confirmed design-export slug), and, once it is time to publish, the Confluence target and the formats wanted.
+Nothing company-specific is built in. Establish these once per project and reuse them for every screen: specs repo and design export, resources root, legacy label endpoint, legacy key prefix, web i18n convention, Confluence target, CMS taxonomy and document language. Secrets live only in a keychain item or a `--headers-file`, never in the mapping, the taxonomy file, the docs or a command line. Ask the user only for what is still unknown. Table with examples: [Project settings](references/project-settings.md).
 
 ## Where this sits
 
-After the screen spec exists: screen spec, then this map, then publish. If the repo holds a snapshot, the registry and the Suggested files are taken from it (see [publish-and-snapshot](reference/publish-and-snapshot.md)).
+After the screen spec exists: screen spec, then this map, then publish. If the repo holds a snapshot, the registry and the Suggested files are taken from it (see [publish-and-snapshot](references/publish-and-snapshot.md)).
 
 ## Steps
 
-The helpers in `scripts/` use nothing beyond the Python 3 standard library, apart from one bash script. Commands and how each source is traced are covered in [sources-and-recipes](reference/sources-and-recipes.md).
+The helpers in `scripts/` use nothing beyond the Python 3 standard library, apart from one bash script. Commands and how each source is traced are covered in [sources-and-recipes](references/sources-and-recipes.md).
 
 1. **Enumerate new keys.** Take the union of three sources: the design export's `components-used.md` across every state frame, each component's registry `localizationKeys`, and the keys the screen code wires. Tag each key screen-specific, component-owned or shared. Every key is confirmed by comparing sources, never lifted from one of them.
 2. **Catch what the cross-reference misses.** First find the type the project generates its keys into (for example `grep -rhoE '\b[A-Z][A-Za-z0-9_]*\.[A-Z][A-Za-z0-9_]*\.[A-Za-z_]+' <dir> | cut -d. -f1 | sort | uniq -c | sort -rn`) and set it as `"keyType"` in the mapping; the built-in default `L10n` is only a fallback, and a project that uses another accessor gets its real keys missed or downgraded to weak. Then run `scan-screen-keys.py --screen-path <dir> --key-type <KeyType>`. A `WARNING: no key chain of ...` line on stderr means the type is wrong: fix it before going on. Each `error` and `dynamic` hit becomes a mapping row; compare the `static` hits with the union from step 1.
@@ -56,13 +41,13 @@ The helpers in `scripts/` use nothing beyond the Python 3 standard library, apar
 4. **CMS copy.** Run `fetch-annotations.py --mapping <map>.json [--local <export-screen-dir>]`: it reads REST and falls back to `--local` when REST fails. When REST is rate-limited or has no token, dump the annotations through Figma MCP and run it again with `--from-mcp <dump>.json`. Fill `cms` and `cmsNodeId` on each row, and send any TR without EN back to the content team.
 5. **Trace legacy keys** per platform: spec, then view controller, view model and cell presentation models on iOS; layout `@string/` on Android; call sites on web.
 6. **Legacy values.** Run `resolve-legacy-values.py --keys "<legacy>" --snapshot-root <res>/Localization/Legacy --langs all`; if the snapshot is out of date, `fetch-legacy-labels.py` refreshes it. A value that cannot be found stays blank and gets a note.
-7. **Assemble the mapping JSON**: one row per element, plus `screenshot`, `figmaFileKey` and `legacyKeyPrefix` where they apply. Schema: [format-and-output](reference/format-and-output.md).
+7. **Assemble the mapping JSON**: one row per element, plus `screenshot`, `figmaFileKey` and `legacyKeyPrefix` where they apply. Schema: [format-and-output](references/format-and-output.md).
 8. **Overlay.** Run `render-overlay.py --out <dir> --mapping <map>.json`; it produces `<slug>.overlay.png`, which the mapping's `overlay` field then names.
 9. **Key screenshots.** Run `render-key-shots.py --out <dir> --mapping <map>.json [--slug]`; it fills `keyshots/` and writes the manifest, which the mapping's `keyshots` field then names.
 10. **Artifacts.** `build-artifact.py <map>.json --out <dir>` (add `--docx`, `--pdf` or `--all` on request).
 11. **Spreadsheet.** `build-spreadsheet.py <map>.json --out <dir>` (add `--csv` or `--csv-only`).
 12. **Gate.** Run `verify-map.py --screen-path <dir> --mapping <map>.json [--resources-root <res>]`, with the accessor from step 2 in the mapping's `keyType` (or passed as `--key-type <KeyType>`). Exit code 2 stops publishing. A PASS that carries the key type `WARNING` is not a pass: set the accessor and run it again.
-13. **Publish.** Ask which target(s): (A) Confluence via `publish-confluence.py`, (B) a specs-repo PR under `localizations/<slug>/`, or both. Details: [publish-and-snapshot](reference/publish-and-snapshot.md).
+13. **Publish.** Ask which target(s): (A) Confluence via `publish-confluence.py`, (B) a specs-repo PR under `localizations/<slug>/`, or both. Details: [publish-and-snapshot](references/publish-and-snapshot.md).
 
 When the Figma frame carries no annotations, say so, explain that keys will be mapped by reading the screen, and confirm the screen state (mock or screenshot) and the anchored element list with the user before rendering.
 
@@ -96,7 +81,8 @@ Edge cases:
 
 ## References
 
-- [sources-and-recipes](reference/sources-and-recipes.md): the origin of every column, legacy tracing on each platform, overlay and keyshot geometry, pitfalls.
-- [format-and-output](reference/format-and-output.md): the mapping schema, artifact formats, spreadsheet columns and the script reference.
-- [publish-and-snapshot](reference/publish-and-snapshot.md): the snapshot that keeps reads in one repo, Confluence publishing, and the specs-repo PR.
+- [Project settings](references/project-settings.md): the per-project settings table with examples, and the questions to ask at the start.
+- [sources-and-recipes](references/sources-and-recipes.md): the origin of every column, legacy tracing on each platform, overlay and keyshot geometry, pitfalls.
+- [format-and-output](references/format-and-output.md): the mapping schema, artifact formats, spreadsheet columns and the script reference.
+- [publish-and-snapshot](references/publish-and-snapshot.md): the snapshot that keeps reads in one repo, Confluence publishing, and the specs-repo PR.
 - [example mapping](example-mapping.json): a neutral mapping of nine rows that covers each edge case listed above.

package/pipeline/skills/shared/external/localization-reuse-map/references/project-settings.md

@@ -0,0 +1,22 @@
+# Project settings
+
+The per-project settings this skill needs before mapping any screen, with an example for each, and what to ask the user at the start.
+
+## Project settings
+
+Nothing company-specific is built in. Establish these once per project (read them from the project's docs or ask), then reuse them for every screen:
+
+| Setting | What it is | Example |
+|---|---|---|
+| Specs repo + design export | Screen frames, `components-used.md`, `screenshot.png`, `tree.json` | `design-export/<project>/screens/<slug>/` |
+| Resources root | Suggested new values and the component registry | `resources/Localization/Suggested/<Key>.json` |
+| Legacy label endpoint | For refreshing the legacy snapshot | `--endpoint` + `--headers-file` |
+| Legacy key prefix | Display-only prefix the backend stores | mapping `legacyKeyPrefix`, e.g. `App-` |
+| Web i18n convention | For legacy and/or new web apps | `t('key')` / `$t('key')`, keys in `locales/<lang>.json` |
+| Confluence target | Base URL, space, parent page | `CONFLUENCE_BASE_URL` / `CONFLUENCE_SPACE` / `CONFLUENCE_PARENT` |
+| CMS taxonomy | Property Group / Module buckets in the spreadsheet | `--taxonomy cms-taxonomy.json` |
+| Document language | Headings, legend and labels | `--ui-lang en` (default) or `tr` |
+
+Secrets live only in a keychain item or a `--headers-file`. They never go into the mapping, the taxonomy file, the docs or a command line.
+
+At the start, ask the user only for what is still unknown: where the implemented screen lives, the Figma file key and node-ids (or a confirmed design-export slug), and, once it is time to publish, the Confluence target and the formats wanted.

package/pipeline/skills/shared/external/mapkit-location/SKILL.md

@@ -90,30 +90,7 @@ Go through the [Review Checklist](#review-checklist) below.
 
 A SwiftUI map file imports both `SwiftUI` and `MapKit`.
 
-```swift
-import SwiftUI
-import MapKit
-
-struct TrailheadMap: View {
-    @State private var camera: MapCameraPosition = .automatic
-
-    private let lot = CLLocationCoordinate2D(latitude: 46.852, longitude: -121.760)
-    private let summit = CLLocationCoordinate2D(latitude: 46.853, longitude: -121.727)
-
-    var body: some View {
-        Map(position: $camera) {
-            Marker("Parking", coordinate: lot)
-            Marker("Summit", systemImage: "mountain.2.fill", coordinate: summit)
-        }
-        .mapStyle(.standard(elevation: .realistic))
-        .mapControls {
-            MapUserLocationButton()
-            MapCompass()
-            MapScaleView()
-        }
-    }
-}
-```
+Code: [SwiftUI Map (iOS 17+)](references/code-examples.md#swiftui-map-ios-17).
 
 ### Marker or Annotation
 
@@ -174,26 +151,7 @@ region are in [Camera Control](references/mapkit-patterns.md#camera-control).
 The value in `.tag(_:)` must have the same type as the `selection` binding,
 or taps select nothing.
 
-```swift
-struct CampsiteMap: View {
-    let sites: [Campsite]
-    @State private var chosen: MKMapItem?
-    @State private var headline = ""
-
-    var body: some View {
-        Map(selection: $chosen) {
-            ForEach(sites) { site in
-                Marker(site.name, coordinate: site.coordinate)
-                    .tag(site.mapItem)
-            }
-        }
-        .onChange(of: chosen) { _, item in
-            guard let item else { return }
-            headline = item.name ?? ""
-        }
-    }
-}
-```
+Code: [Selection](references/code-examples.md#selection).
 
 ## CoreLocation
 
@@ -210,39 +168,7 @@ element is a `CLLocationUpdate` whose `location` is optional. Rules:
   sufficiently in use). React with a visible fallback instead of waiting on a
   sequence that will not deliver.
 
-```swift
-import CoreLocation
-import Observation
-
-@MainActor
-@Observable
-final class RunTracker {
-    private(set) var lastFix: CLLocation?
-    private var stream: Task<Void, Never>?
-
-    func begin() {
-        stream?.cancel()
-        stream = Task {
-            do {
-                for try await reading in CLLocationUpdate.liveUpdates() {
-                    guard let fix = reading.location,
-                          fix.horizontalAccuracy >= 0,
-                          fix.horizontalAccuracy < 50 else { continue }
-                    lastFix = fix
-                }
-            } catch is CancellationError {
-            } catch {
-                lastFix = nil
-            }
-        }
-    }
-
-    func end() {
-        stream?.cancel()
-        stream = nil
-    }
-}
-```
+Code: [CLLocationUpdate.liveUpdates() (iOS 17+)](references/code-examples.md#cllocationupdateliveupdates-ios-17).
 
 Diagnostics, the full filter set and a mapping from each state to UI are in
 the [location reference](references/mapkit-corelocation-patterns.md#diagnostics-and-fallbacks-ios-18).
@@ -271,24 +197,7 @@ let nearbySession = CLServiceSession(
 
 A denied user should see why the feature is empty and a way out:
 
-```swift
-struct LocationOffView: View {
-    @Environment(\.openURL) private var openURL
-
-    var body: some View {
-        ContentUnavailableView {
-            Label("Location is off", systemImage: "location.slash")
-        } description: {
-            Text("Allow location access to see trails near you.")
-        } actions: {
-            Button("Open Settings") {
-                guard let settings = URL(string: UIApplication.openSettingsURLString) else { return }
-                openURL(settings)
-            }
-        }
-    }
-}
-```
+Code: [Authorization](references/code-examples.md#authorization).
 
 ## Geocoding
 
@@ -459,3 +368,4 @@ func mapItem(near point: CLLocationCoordinate2D, named name: String) async throw
 - [Location patterns](references/mapkit-corelocation-patterns.md):
   `CLLocationUpdate`, `CLServiceSession`, `CLMonitor`, background location,
   testing, privacy keys.
+- [Code examples](references/code-examples.md): open for the full code behind SwiftUI Map (iOS 17+), Selection, CLLocationUpdate.liveUpdates() (iOS 17+), Authorization.