opencode-skills-collection 4.1.14 → 4.1.16

package/bundled-skills/swiftui-ui-patterns/references/form.md

@@ -51,7 +51,15 @@ struct AddRemoteServerView: View {
   @Environment(Theme.self) private var theme
 
   @State private var server: String = ""
-  @State private var isValid = false
+  let onAdd: (URL) async throws -> Void // Existing authorized project operation.
+  @State private var isSaving = false
+  @State private var saveError: String?
+  private var validatedURL: URL? {
+    guard let url = URL(string: server.trimmingCharacters(in: .whitespacesAndNewlines)),
+          url.scheme == "https", let host = url.host, !host.isEmpty,
+          url.user == nil, url.password == nil else { return nil }
+    return url
+  }
   @FocusState private var isServerFieldFocused: Bool
 
   var body: some View {
@@ -65,11 +73,19 @@ struct AddRemoteServerView: View {
           .listRowBackground(theme.primaryBackgroundColor)
 
         Button("Add") {
-          guard isValid else { return }
-          dismiss()
+          guard !isSaving, let url = validatedURL else { return }
+          isSaving = true
+          Task {
+            defer { isSaving = false }
+            do {
+              try await onAdd(url)
+              dismiss()
+            } catch { saveError = "Could not add the server. Please try again." }
+          }
         }
-        .disabled(!isValid)
+        .disabled(validatedURL == nil || isSaving)
         .listRowBackground(theme.primaryBackgroundColor)
+        if let saveError { Text(saveError) }
       }
       .formStyle(.grouped)
       .navigationTitle("Add Server")
@@ -84,6 +100,8 @@ struct AddRemoteServerView: View {
 }
 ```
 
+The URL check is form validation, not an SSRF boundary. The injected operation must independently verify the authorized server, identity, redirects, network policy and actual persistence before returning success.
+
 ## Design choices to keep
 
 - Prefer `Form` over custom stacks for settings and input screens.

package/bundled-skills/swiftui-ui-patterns/references/lightweight-clients.md

@@ -16,13 +16,13 @@ struct SomeClient {
 
 extension SomeClient {
     static func live(baseURL: URL = URL(string: "https://example.com")!) -> SomeClient {
-        let session = URLSession.shared
+        // Scaffold only: no live network implementation is bundled.
         return SomeClient(
             fetchItems: { limit in
-                // build URL, call session, decode
+                throw URLError(.unsupportedURL) // Implement and test the project adapter before use.
             },
             search: { query, limit in
-                // build URL, call session, decode
+                throw URLError(.unsupportedURL) // Implement and test the project adapter before use.
             }
         )
     }

package/bundled-skills/swiftui-ui-patterns/references/list.md

@@ -13,7 +13,7 @@ Use `List` for feed-style content and settings-style rows where built-in row reu
 - Use `.listStyle(.grouped)` for multi-section discovery/search pages where section grouping helps.
 - Apply `.scrollContentBackground(.hidden)` + a custom background when you need a themed surface.
 - Use `.listRowInsets(...)` and `.listRowSeparator(.hidden)` to tune row spacing and separators.
-- Use `.environment(\\.defaultMinListRowHeight, ...)` to control dense list layouts.
+- Use `.environment(\.defaultMinListRowHeight, ...)` to control dense list layouts.
 
 ## Example: feed list with scroll-to-top
 
@@ -34,7 +34,7 @@ struct TimelineListView: View {
         }
       }
       .listStyle(.plain)
-      .environment(\\.defaultMinListRowHeight, 1)
+      .environment(\.defaultMinListRowHeight, 1)
       .onChange(of: scrollToId) { _, newValue in
         if let newValue {
           proxy.scrollTo(newValue, anchor: .top)

package/bundled-skills/swiftui-ui-patterns/references/matched-transitions.md

@@ -17,10 +17,12 @@ Use matched transitions to create smooth continuity between a source view (thumb
 struct MediaPreview: View {
   @Namespace private var namespace
   @State private var selected: MediaAttachment?
+  let attachment: MediaAttachment
 
   var body: some View {
     ThumbnailView()
-      .matchedTransitionSource(id: selected?.id ?? "", in: namespace)
+      .matchedTransitionSource(id: attachment.id, in: namespace)
+      .onTapGesture { selected = attachment }
       .sheet(item: $selected) { item in
         MediaViewer(item: item)
           .navigationTransition(.zoom(sourceID: item.id, in: namespace))

package/bundled-skills/swiftui-ui-patterns/references/media.md

@@ -26,6 +26,9 @@ struct MediaPreviewRow: View {
           LazyImage(url: attachment.previewURL) { state in
             if let image = state.image {
               image.resizable().aspectRatio(contentMode: .fill)
+            } else if state.error != nil {
+              Image(systemName: "photo.badge.exclamationmark")
+                .accessibilityLabel("Image unavailable")
             } else {
               ProgressView()
             }

package/bundled-skills/swiftui-ui-patterns/references/overlay.md

@@ -22,10 +22,15 @@ struct AppRootView: View {
         if let toast {
           ToastView(toast: toast)
             .transition(.move(edge: .top).combined(with: .opacity))
-            .onAppear {
-              DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
+            .task(id: toast.id) {
+              do {
+                try await Task.sleep(for: .seconds(2))
+                try Task.checkCancellation()
+                guard self.toast?.id == toast.id else { return }
                 withAnimation { self.toast = nil }
-              }
+              } catch is CancellationError {
+                return
+              } catch { return }
             }
         }
       }

package/bundled-skills/swiftui-ui-patterns/references/performance.md

@@ -32,11 +32,8 @@ ForEach(Array(items.enumerated()), id: \.offset) { _, item in
 
 ```swift
 struct FeedView: View {
-  let items: [FeedItem]
-
-  private var sortedItems: [FeedItem] {
-    items.sorted(using: KeyPathComparator(\.createdAt, order: .reverse))
-  }
+  // Sorted and cached by the owning store when its input changes.
+  let sortedItems: [FeedItem]
 
   var body: some View {
     List(sortedItems) { item in

package/bundled-skills/swiftui-ui-patterns/references/scroll-reveal.md

@@ -127,7 +127,9 @@ This keeps the motion coherent and avoids duplicate-hit-target bugs.
 - Do not store derived state like `isSecondaryVisible` unless another API requires it. Prefer deriving it from `progress` or visible scroll targets.
 - Beware of layout feedback loops when measuring heights. Clamp zero values and update only when the measured height actually changes.
 
-## Concrete example
+## Historical author examples
+
+These are the original author’s private checkout paths, not bundled files or prerequisites. Use the self-contained schematic pattern above and real files from the current project; do not claim these historical files were opened.
 
 - Pool iOS tile detail reveal: `/Users/dimillian/Documents/Dev/Pool/pool-ios/Pool/Sources/Features/Tile/Detail/TileDetailView.swift`
 - Secondary content anchor example: `/Users/dimillian/Documents/Dev/Pool/pool-ios/Pool/Sources/Features/Tile/Detail/TileDetailIntentListView.swift`

package/bundled-skills/swiftui-ui-patterns/references/searchable.md

@@ -41,20 +41,36 @@ struct ExploreView: View {
         Text(scope.title)
       }
     }
-    .task(id: searchQuery) {
-      await runSearch()
+    .task(id: [searchQuery, String(describing: searchScope)]) {
+      await runSearch(query: searchQuery, scope: searchScope)
     }
   }
 
-  private func runSearch() async {
-    guard !searchQuery.isEmpty else {
+  private func runSearch(query requestedQuery: String, scope requestedScope: SearchScope) async {
+    guard !requestedQuery.isEmpty else {
       results = []
+      isSearching = false
       return
     }
     isSearching = true
-    defer { isSearching = false }
-    try? await Task.sleep(for: .milliseconds(250))
-    results = await fetchResults(query: searchQuery, scope: searchScope)
+    defer {
+      if !Task.isCancelled && searchQuery == requestedQuery && searchScope == requestedScope {
+        isSearching = false
+      }
+    }
+    do {
+      try await Task.sleep(for: .milliseconds(250))
+      try Task.checkCancellation()
+      let fetched = await fetchResults(query: requestedQuery, scope: requestedScope)
+      try Task.checkCancellation()
+      guard searchQuery == requestedQuery && searchScope == requestedScope else { return }
+      results = fetched
+    } catch is CancellationError {
+      return
+    } catch {
+      guard !Task.isCancelled else { return }
+      results = []
+    }
   }
 }
 ```

package/bundled-skills/swiftui-ui-patterns/references/sheets.md

@@ -34,13 +34,10 @@ enum SheetDestination: Identifiable, Hashable {
 
   var id: String {
     switch self {
-    case .composer, .editProfile:
-      // Use the same id to ensure only one editor-like sheet is active at a time.
-      return "editor"
-    case .settings:
-      return "settings"
-    case .report:
-      return "report"
+    case .composer: return "composer"
+    case .editProfile: return "edit-profile"
+    case .settings: return "settings"
+    case .report(let itemID): return "report-\(itemID)"
     }
   }
 }
@@ -122,19 +119,28 @@ struct EditItemSheet: View {
 
   let item: Item
   @State private var isSaving = false
+  @State private var saveError: String?
 
   var body: some View {
     VStack {
       Button(isSaving ? "Saving..." : "Save") {
         Task { await save() }
       }
+      .disabled(isSaving)
+      if let saveError { Text(saveError) }
     }
   }
 
   private func save() async {
+    guard !isSaving else { return }
     isSaving = true
-    await store.save(item)
-    dismiss()
+    defer { isSaving = false }
+    do {
+      try await store.save(item) // Project adapter must report actual failure.
+      dismiss()
+    } catch {
+      saveError = "Save failed. Please try again."
+    }
   }
 }
 ```
@@ -143,7 +149,7 @@ struct EditItemSheet: View {
 
 - Centralize sheet routing so features can present modals without wiring bindings through many layers.
 - Use `sheet(item:)` to guarantee a single sheet is active and to drive presentation from the enum.
-- Group related sheets under the same `id` when they are mutually exclusive (e.g., editor flows).
+- Give every destination a distinct stable identity, including its associated item ID. One optional sheet value already expresses mutual exclusion; sharing IDs can preserve the wrong content.
 - Keep sheet views lightweight and composed from smaller views; avoid large monoliths.
 - Let sheets own their actions and call `dismiss()` internally instead of forwarding `onCancel` or `onConfirm` closures through many layers.
 

package/bundled-skills/swiftui-ui-patterns/references/split-views.md

@@ -49,7 +49,10 @@ struct AppView: View {
 
 ## Alternative: NavigationSplitView
 
-`NavigationSplitView` can handle sidebar + detail + supplementary columns for you, but is harder to customize in cases like:\n- a dedicated notification column independent of selection,\n- custom sizing, or\n- different toolbar behaviors per column.
+`NavigationSplitView` can handle sidebar + detail + supplementary columns for you, but is harder to customize in cases like:
+- a dedicated notification column independent of selection,
+- custom sizing, or
+- different toolbar behaviors per column.
 
 ```swift
 @MainActor

package/bundled-skills/systematic-debugging/condition-based-waiting-example.ts

@@ -5,154 +5,40 @@
 import type { ThreadManager } from '~/threads/thread-manager';
 import type { LaceEvent, LaceEventType } from '~/threads/types';
 
-/**
- * Wait for a specific event type to appear in thread
- *
- * @param threadManager - The thread manager to query
- * @param threadId - Thread to check for events
- * @param eventType - Type of event to wait for
- * @param timeoutMs - Maximum time to wait (default 5000ms)
- * @returns Promise resolving to the first matching event
- *
- * Example:
- *   await waitForEvent(threadManager, agentThreadId, 'TOOL_RESULT');
- */
-export function waitForEvent(
-  threadManager: ThreadManager,
-  threadId: string,
-  eventType: LaceEventType,
-  timeoutMs = 5000
-): Promise<LaceEvent> {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-
-    const check = () => {
-      const events = threadManager.getEvents(threadId);
-      const event = events.find((e) => e.type === eventType);
-
-      if (event) {
-        resolve(event);
-      } else if (Date.now() - startTime > timeoutMs) {
-        reject(new Error(`Timeout waiting for ${eventType} event after ${timeoutMs}ms`));
-      } else {
-        setTimeout(check, 10); // Poll every 10ms for efficiency
-      }
-    };
-
-    check();
-  });
+// Requires the source project's Lace interfaces. Polling reads must be synchronous.
+// Bounds cannot interrupt a blocking getter; rejected getters stop without another timer.
+async function poll<T>(read: () => T | undefined, description: string, timeoutMs: number): Promise<T> {
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) throw new Error('Invalid timeout');
+  const deadline = performance.now() + timeoutMs;
+  while (true) {
+    const value = read();
+    if (value !== undefined) return value;
+    if (performance.now() >= deadline) throw new Error(`Timeout waiting for ${description}`);
+    await new Promise<void>(resolve => setTimeout(resolve, 10));
+  }
 }
 
-/**
- * Wait for a specific number of events of a given type
- *
- * @param threadManager - The thread manager to query
- * @param threadId - Thread to check for events
- * @param eventType - Type of event to wait for
- * @param count - Number of events to wait for
- * @param timeoutMs - Maximum time to wait (default 5000ms)
- * @returns Promise resolving to all matching events once count is reached
- *
- * Example:
- *   // Wait for 2 AGENT_MESSAGE events (initial response + continuation)
- *   await waitForEventCount(threadManager, agentThreadId, 'AGENT_MESSAGE', 2);
- */
-export function waitForEventCount(
-  threadManager: ThreadManager,
-  threadId: string,
-  eventType: LaceEventType,
-  count: number,
-  timeoutMs = 5000
-): Promise<LaceEvent[]> {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-
-    const check = () => {
-      const events = threadManager.getEvents(threadId);
-      const matchingEvents = events.filter((e) => e.type === eventType);
-
-      if (matchingEvents.length >= count) {
-        resolve(matchingEvents);
-      } else if (Date.now() - startTime > timeoutMs) {
-        reject(
-          new Error(
-            `Timeout waiting for ${count} ${eventType} events after ${timeoutMs}ms (got ${matchingEvents.length})`
-          )
-        );
-      } else {
-        setTimeout(check, 10);
-      }
-    };
-
-    check();
-  });
+export function waitForEvent(manager: ThreadManager, threadId: string,
+  eventType: LaceEventType, timeoutMs = 5000): Promise<LaceEvent> {
+  return poll(() => manager.getEvents(threadId).find(event => event.type === eventType),
+    eventType, timeoutMs);
 }
 
-/**
- * Wait for an event matching a custom predicate
- * Useful when you need to check event data, not just type
- *
- * @param threadManager - The thread manager to query
- * @param threadId - Thread to check for events
- * @param predicate - Function that returns true when event matches
- * @param description - Human-readable description for error messages
- * @param timeoutMs - Maximum time to wait (default 5000ms)
- * @returns Promise resolving to the first matching event
- *
- * Example:
- *   // Wait for TOOL_RESULT with specific ID
- *   await waitForEventMatch(
- *     threadManager,
- *     agentThreadId,
- *     (e) => e.type === 'TOOL_RESULT' && e.data.id === 'call_123',
- *     'TOOL_RESULT with id=call_123'
- *   );
- */
-export function waitForEventMatch(
-  threadManager: ThreadManager,
-  threadId: string,
-  predicate: (event: LaceEvent) => boolean,
-  description: string,
-  timeoutMs = 5000
-): Promise<LaceEvent> {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-
-    const check = () => {
-      const events = threadManager.getEvents(threadId);
-      const event = events.find(predicate);
-
-      if (event) {
-        resolve(event);
-      } else if (Date.now() - startTime > timeoutMs) {
-        reject(new Error(`Timeout waiting for ${description} after ${timeoutMs}ms`));
-      } else {
-        setTimeout(check, 10);
-      }
-    };
+export function waitForEventCount(manager: ThreadManager, threadId: string,
+  eventType: LaceEventType, count: number, timeoutMs = 5000): Promise<LaceEvent[]> {
+  if (!Number.isInteger(count) || count < 1) return Promise.reject(new Error('Invalid count'));
+  return poll(() => {
+    const events = manager.getEvents(threadId).filter(event => event.type === eventType);
+    return events.length >= count ? events : undefined;
+  }, `${count} ${eventType} events`, timeoutMs);
+}
 
-    check();
-  });
+export function waitForEventMatch(manager: ThreadManager, threadId: string,
+  predicate: (event: LaceEvent) => boolean, description: string,
+  timeoutMs = 5000): Promise<LaceEvent> {
+  return poll(() => manager.getEvents(threadId).find(predicate), description, timeoutMs);
 }
 
-// Usage example from actual debugging session:
-//
-// BEFORE (flaky):
-// ---------------
-// const messagePromise = agent.sendMessage('Execute tools');
-// await new Promise(r => setTimeout(r, 300)); // Hope tools start in 300ms
-// agent.abort();
-// await messagePromise;
-// await new Promise(r => setTimeout(r, 50));  // Hope results arrive in 50ms
-// expect(toolResults.length).toBe(2);         // Fails randomly
-//
-// AFTER (reliable):
-// ----------------
-// const messagePromise = agent.sendMessage('Execute tools');
-// await waitForEventCount(threadManager, threadId, 'TOOL_CALL', 2); // Wait for tools to start
-// agent.abort();
-// await messagePromise;
-// await waitForEventCount(threadManager, threadId, 'TOOL_RESULT', 2); // Wait for results
-// expect(toolResults.length).toBe(2); // Always succeeds
-//
-// Result: 60% pass rate → 100%, 40% faster execution
+// Scope observations to the current thread/request and await the actual tool events
+// before cancelling or asserting. Historical source outcomes (15 repaired cases,
+// 60% to 100% observed pass rate) are not a guarantee for other tests.

package/bundled-skills/systematic-debugging/condition-based-waiting.md

@@ -97,7 +97,7 @@ See `condition-based-waiting-example.ts` in this directory for complete implemen
 
 ```typescript
 // Tool ticks every 100ms - need 2 ticks to verify partial output
-await waitForEvent(manager, 'TOOL_STARTED'); // First: wait for condition
+await waitForEvent(manager, threadId, 'TOOL_CALL'); // First: wait for condition
 await new Promise(r => setTimeout(r, 200));   // Then: wait for timed behavior
 // 200ms = 2 ticks at 100ms intervals - documented and justified
 ```

package/bundled-skills/tdd-orchestrator/SKILL.md

@@ -21,7 +21,6 @@ date_added: '2026-02-27'
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 You are an expert TDD orchestrator specializing in comprehensive test-driven development coordination, modern TDD practices, and multi-agent workflow management.
 

package/bundled-skills/team-composition-analysis/SKILL.md

@@ -5,6 +5,15 @@ risk: none
 source: community
 date_added: '2026-02-27'
 ---
+## Supporting material availability
+
+This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
+
+- `<support-root>/references/compensation-benchmarks.md`
+- `<support-root>/references/equity-calculator.md`
+
+Ask for the original supporting material or an existing installation before using a step that depends on these paths; this catalog does not identify a verified download source for them. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
+
 
 # Team Composition Analysis
 
@@ -25,7 +34,6 @@ Design optimal team structures, hiring plans, compensation strategies, and equit
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 ## Overview
 

package/bundled-skills/technical-tutorials/SKILL.md

@@ -18,7 +18,7 @@ Read [the detailed guide](references/detailed-guide.md) before executing this sk
 
 ## When to Use
 
-Use this skill when you need when the user wants to create step-by-step technical tutorials, quickstarts, or code walkthroughs. Trigger phrases include "tutorial," "quickstart," "getting started guide," "walkthrough," "step by step," "how to guide," "hands-on guide," or "code tutorial.".
+Use this skill when you need to create step-by-step technical tutorials, quickstarts, or code walkthroughs. Trigger phrases include "tutorial," "quickstart," "getting started guide," "walkthrough," "step by step," "how to guide," "hands-on guide," or "code tutorial.".
 
 
 This skill helps you create step-by-step tutorials that actually work. Covers prerequisite handling, progressive complexity, troubleshooting sections, and creating those satisfying "it works!" moments.

package/bundled-skills/temporal-python-pro/SKILL.md

@@ -21,7 +21,6 @@ date_added: '2026-02-27'
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 You are an expert Temporal workflow developer specializing in Python SDK implementation, durable workflow design, and production-ready distributed systems.
 

package/bundled-skills/temporal-python-testing/SKILL.md

@@ -20,7 +20,6 @@ Comprehensive testing approaches for Temporal workflows using pytest, progressiv
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 ## Use this skill when
 

package/bundled-skills/terraform-module-library/SKILL.md

@@ -5,6 +5,17 @@ risk: critical
 source: community
 date_added: "2026-02-27"
 ---
+## Supporting material availability
+
+This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
+
+- `<support-root>/assets/vpc-module/`
+- `<support-root>/assets/rds-module/`
+- `<support-root>/references/azure-modules.md`
+- `<support-root>/references/gcp-modules.md`
+
+Ask for the original supporting material or an existing installation before using a step that depends on these paths; this catalog does not identify a verified download source for them. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
+
 
 # Terraform Module Library
 
@@ -20,7 +31,6 @@ Production-ready Terraform module patterns for AWS, Azure, and GCP infrastructur
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 ## Purpose
 

package/bundled-skills/test-automator/SKILL.md

@@ -21,7 +21,6 @@ date_added: '2026-02-27'
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 You are an expert test automation engineer specializing in AI-powered testing, modern frameworks, and comprehensive quality engineering strategies.
 

package/bundled-skills/testing-patterns/SKILL.md

@@ -159,16 +159,16 @@ describe('ComponentName', () => {
   });
 
   describe('Rendering', () => {
-    it('should render component with default props', () => {});
-    it('should render loading state when loading', () => {});
+    it.todo('should render component with default props');
+    it.todo('should render loading state when loading');
   });
 
   describe('User interactions', () => {
-    it('should call onPress when button is clicked', async () => {});
+    it.todo('should call onPress when button is clicked');
   });
 
   describe('Edge cases', () => {
-    it('should handle empty data gracefully', () => {});
+    it.todo('should handle empty data gracefully');
   });
 });
 ```
@@ -183,15 +183,14 @@ expect(screen.getByText('Hello')).toBeTruthy();
 expect(screen.queryByText('Goodbye')).toBeNull();
 
 // Element appears asynchronously
-await waitFor(() => {
-  expect(screen.findByText('Loaded')).toBeTruthy();
-});
+// async-appearance-example: await the element, not the Promise
+expect(await screen.findByText('Loaded')).toBeTruthy();
 ```
 
 ## User Interaction Patterns
 
 ```typescript
-import { fireEvent, screen } from '@testing-library/react-native';
+import { fireEvent, screen, waitFor } from '@testing-library/react-native';
 
 it('should submit form on button click', async () => {
   const onSubmit = jest.fn();
@@ -262,7 +261,7 @@ npm test ComponentName.test.tsx
 - **systematic-debugging**: Write test that reproduces bug before fixing
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+Use when writing Jest unit tests, test factories and mocks, or diagnosing a failing test through a red-green-refactor cycle.
 
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.