[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M73DEG7M983WH01Z49GCQ25D":3,"skill-same:01M73DEG7M983WH01Z49GCQ25D":49},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":30,"ownerHtmlUrl":31,"ownerBlogUrl":32,"ownerDescription":33,"updatedAt":34,"install":35,"resources":48},"01M73DEG7M983WH01Z49GCQ25D","kotlin-coroutines-flows",null,"Kotlin Coroutines and Flow patterns for Android and KMP — structured concurrency, Flow operators, StateFlow, error handling, and testing.","Horonomos-laps\u002FYana-AI","Horonomos-laps","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F355299122?v=4","01M76B3QPXE88ET2SQPDPVATZT"," Horonomos-laps","01M72ZQRJPCYPSSWT4D00VJR2A",13,"Apache-2.0","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fkotlin-coroutines-flows\u002FSKILL.md",[],[],"2026-11-11 15:11:14",false,"---\nname: kotlin-coroutines-flows\ndescription: Kotlin Coroutines and Flow patterns for Android and KMP — structured concurrency, Flow operators, StateFlow, error handling, and testing.\norigin: ECC\n---\n\n# Kotlin Coroutines & Flows\n\nPatterns for structured concurrency, Flow-based reactive streams, and coroutine testing in Android and Kotlin Multiplatform projects.\n\n## When to Activate\n\n- Writing async code with Kotlin coroutines\n- Using Flow, StateFlow, or SharedFlow for reactive data\n- Handling concurrent operations (parallel loading, debounce, retry)\n- Testing coroutines and Flows\n- Managing coroutine scopes and cancellation\n\n## Structured Concurrency\n\n### Scope Hierarchy\n\n```\nApplication\n  └── viewModelScope (ViewModel)\n        └── coroutineScope { } (structured child)\n              ├── async { } (concurrent task)\n              └── async { } (concurrent task)\n```\n\nAlways use structured concurrency — never `GlobalScope`:\n\n```kotlin\n\u002F\u002F BAD\nGlobalScope.launch { fetchData() }\n\n\u002F\u002F GOOD — scoped to ViewModel lifecycle\nviewModelScope.launch { fetchData() }\n\n\u002F\u002F GOOD — scoped to composable lifecycle\nLaunchedEffect(key) { fetchData() }\n```\n\n### Parallel Decomposition\n\nUse `coroutineScope` + `async` for parallel work:\n\n```kotlin\nsuspend fun loadDashboard(): Dashboard = coroutineScope {\n    val items = async { itemRepository.getRecent() }\n    val stats = async { statsRepository.getToday() }\n    val profile = async { userRepository.getCurrent() }\n    Dashboard(\n        items = items.await(),\n        stats = stats.await(),\n        profile = profile.await()\n    )\n}\n```\n\n### SupervisorScope\n\nUse `supervisorScope` when child failures should not cancel siblings:\n\n```kotlin\nsuspend fun syncAll() = supervisorScope {\n    launch { syncItems() }       \u002F\u002F failure here won't cancel syncStats\n    launch { syncStats() }\n    launch { syncSettings() }\n}\n```\n\n## Flow Patterns\n\n### Cold Flow — One-Shot to Stream Conversion\n\n```kotlin\nfun observeItems(): Flow\u003CList\u003CItem>> = flow {\n    \u002F\u002F Re-emits whenever the database changes\n    itemDao.observeAll()\n        .map { entities -> entities.map { it.toDomain() } }\n        .collect { emit(it) }\n}\n```\n\n### StateFlow for UI State\n\n```kotlin\nclass DashboardViewModel(\n    observeProgress: ObserveUserProgressUseCase\n) : ViewModel() {\n    val progress: StateFlow\u003CUserProgress> = observeProgress()\n        .stateIn(\n            scope = viewModelScope,\n            started = SharingStarted.WhileSubscribed(5_000),\n            initialValue = UserProgress.EMPTY\n        )\n}\n```\n\n`WhileSubscribed(5_000)` keeps the upstream active for 5 seconds after the last subscriber leaves — survives configuration changes without restarting.\n\n### Combining Multiple Flows\n\n```kotlin\nval uiState: StateFlow\u003CHomeState> = combine(\n    itemRepository.observeItems(),\n    settingsRepository.observeTheme(),\n    userRepository.observeProfile()\n) { items, theme, profile ->\n    HomeState(items = items, theme = theme, profile = profile)\n}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), HomeState())\n```\n\n### Flow Operators\n\n```kotlin\n\u002F\u002F Debounce search input\nsearchQuery\n    .debounce(300)\n    .distinctUntilChanged()\n    .flatMapLatest { query -> repository.search(query) }\n    .catch { emit(emptyList()) }\n    .collect { results -> _state.update { it.copy(results = results) } }\n\n\u002F\u002F Retry with exponential backoff\nfun fetchWithRetry(): Flow\u003CData> = flow { emit(api.fetch()) }\n    .retryWhen { cause, attempt ->\n        if (cause is IOException && attempt \u003C 3) {\n            delay(1000L * (1 shl attempt.toInt()))\n            true\n        } else {\n            false\n        }\n    }\n```\n\n### SharedFlow for One-Time Events\n\n```kotlin\nclass ItemListViewModel : ViewModel() {\n    private val _effects = MutableSharedFlow\u003CEffect>()\n    val effects: SharedFlow\u003CEffect> = _effects.asSharedFlow()\n\n    sealed interface Effect {\n        data class ShowSnackbar(val message: String) : Effect\n        data class NavigateTo(val route: String) : Effect\n    }\n\n    private fun deleteItem(id: String) {\n        viewModelScope.launch {\n            repository.delete(id)\n            _effects.emit(Effect.ShowSnackbar(\"Item deleted\"))\n        }\n    }\n}\n\n\u002F\u002F Collect in Composable\nLaunchedEffect(Unit) {\n    viewModel.effects.collect { effect ->\n        when (effect) {\n            is Effect.ShowSnackbar -> snackbarHostState.showSnackbar(effect.message)\n            is Effect.NavigateTo -> navController.navigate(effect.route)\n        }\n    }\n}\n```\n\n## Dispatchers\n\n```kotlin\n\u002F\u002F CPU-intensive work\nwithContext(Dispatchers.Default) { parseJson(largePayload) }\n\n\u002F\u002F IO-bound work\nwithContext(Dispatchers.IO) { database.query() }\n\n\u002F\u002F Main thread (UI) — default in viewModelScope\nwithContext(Dispatchers.Main) { updateUi() }\n```\n\nIn KMP, use `Dispatchers.Default` and `Dispatchers.Main` (available on all platforms). `Dispatchers.IO` is JVM\u002FAndroid only — use `Dispatchers.Default` on other platforms or provide via DI.\n\n## Cancellation\n\n### Cooperative Cancellation\n\nLong-running loops must check for cancellation:\n\n```kotlin\nsuspend fun processItems(items: List\u003CItem>) = coroutineScope {\n    for (item in items) {\n        ensureActive()  \u002F\u002F throws CancellationException if cancelled\n        process(item)\n    }\n}\n```\n\n### Cleanup with try\u002Ffinally\n\n```kotlin\nviewModelScope.launch {\n    try {\n        _state.update { it.copy(isLoading = true) }\n        val data = repository.fetch()\n        _state.update { it.copy(data = data) }\n    } finally {\n        _state.update { it.copy(isLoading = false) }  \u002F\u002F always runs, even on cancellation\n    }\n}\n```\n\n## Testing\n\n### Testing StateFlow with Turbine\n\n```kotlin\n@Test\nfun `search updates item list`() = runTest {\n    val fakeRepository = FakeItemRepository().apply { emit(testItems) }\n    val viewModel = ItemListViewModel(GetItemsUseCase(fakeRepository))\n\n    viewModel.state.test {\n        assertEquals(ItemListState(), awaitItem())  \u002F\u002F initial\n\n        viewModel.onSearch(\"query\")\n        val loading = awaitItem()\n        assertTrue(loading.isLoading)\n\n        val loaded = awaitItem()\n        assertFalse(loaded.isLoading)\n        assertEquals(1, loaded.items.size)\n    }\n}\n```\n\n### Testing with TestDispatcher\n\n```kotlin\n@Test\nfun `parallel load completes correctly`() = runTest {\n    val viewModel = DashboardViewModel(\n        itemRepo = FakeItemRepo(),\n        statsRepo = FakeStatsRepo()\n    )\n\n    viewModel.load()\n    advanceUntilIdle()\n\n    val state = viewModel.state.value\n    assertNotNull(state.items)\n    assertNotNull(state.stats)\n}\n```\n\n### Faking Flows\n\n```kotlin\nclass FakeItemRepository : ItemRepository {\n    private val _items = MutableStateFlow\u003CList\u003CItem>>(emptyList())\n\n    override fun observeItems(): Flow\u003CList\u003CItem>> = _items\n\n    fun emit(items: List\u003CItem>) { _items.value = items }\n\n    override suspend fun getItemsByCategory(category: String): Result\u003CList\u003CItem>> {\n        return Result.success(_items.value.filter { it.category == category })\n    }\n}\n```\n\n## Anti-Patterns to Avoid\n\n- Using `GlobalScope` — leaks coroutines, no structured cancellation\n- Collecting Flows in `init {}` without a scope — use `viewModelScope.launch`\n- Using `MutableStateFlow` with mutable collections — always use immutable copies: `_state.update { it.copy(list = it.list + newItem) }`\n- Catching `CancellationException` — let it propagate for proper cancellation\n- Using `flowOn(Dispatchers.Main)` to collect — collection dispatcher is the caller's dispatcher\n- Creating `Flow` in `@Composable` without `remember` — recreates the flow every recomposition\n\n## References\n\nSee skill: `compose-multiplatform-patterns` for UI consumption of Flows.\nSee skill: `android-clean-architecture` for where coroutines fit in layers.\n","# Kotlin Coroutines & Flows\n\nPatterns for structured concurrency, Flow-based reactive streams, and coroutine testing in Android and Kotlin Multiplatform projects.\n\n## When to Activate\n\n- Writing async code with Kotlin coroutines\n- Using Flow, StateFlow, or SharedFlow for reactive data\n- Handling concurrent operations (parallel loading, debounce, retry)\n- Testing coroutines and Flows\n- Managing coroutine scopes and cancellation\n\n## Structured Concurrency\n\n### Scope Hierarchy\n\n```\nApplication\n  └── viewModelScope (ViewModel)\n        └── coroutineScope { } (structured child)\n              ├── async { } (concurrent task)\n              └── async { } (concurrent task)\n```\n\nAlways use structured concurrency — never `GlobalScope`:\n\n```kotlin\n\u002F\u002F BAD\nGlobalScope.launch { fetchData() }\n\n\u002F\u002F GOOD — scoped to ViewModel lifecycle\nviewModelScope.launch { fetchData() }\n\n\u002F\u002F GOOD — scoped to composable lifecycle\nLaunchedEffect(key) { fetchData() }\n```\n\n### Parallel Decomposition\n\nUse `coroutineScope` + `async` for parallel work:\n\n```kotlin\nsuspend fun loadDashboard(): Dashboard = coroutineScope {\n    val items = async { itemRepository.getRecent() }\n    val stats = async { statsRepository.getToday() }\n    val profile = async { userRepository.getCurrent() }\n    Dashboard(\n        items = items.await(),\n        stats = stats.await(),\n        profile = profile.await()\n    )\n}\n```\n\n### SupervisorScope\n\nUse `supervisorScope` when child failures should not cancel siblings:\n\n```kotlin\nsuspend fun syncAll() = supervisorScope {\n    launch { syncItems() }       \u002F\u002F failure here won't cancel syncStats\n    launch { syncStats() }\n    launch { syncSettings() }\n}\n```\n\n## Flow Patterns\n\n### Cold Flow — One-Shot to Stream Conversion\n\n```kotlin\nfun observeItems(): Flow\u003CList\u003CItem>> = flow {\n    \u002F\u002F Re-emits whenever the database changes\n    itemDao.observeAll()\n        .map { entities -> entities.map { it.toDomain() } }\n        .collect { emit(it) }\n}\n```\n\n### StateFlow for UI State\n\n```kotlin\nclass DashboardViewModel(\n    observeProgress: ObserveUserProgressUseCase\n) : ViewModel() {\n    val progress: StateFlow\u003CUserProgress> = observeProgress()\n        .stateIn(\n            scope = viewModelScope,\n            started = SharingStarted.WhileSubscribed(5_000),\n            initialValue = UserProgress.EMPTY\n        )\n}\n```\n\n`WhileSubscribed(5_000)` keeps the upstream active for 5 seconds after the last subscriber leaves — survives configuration changes without restarting.\n\n### Combining Multiple Flows\n\n```kotlin\nval uiState: StateFlow\u003CHomeState> = combine(\n    itemRepository.observeItems(),\n    settingsRepository.observeTheme(),\n    userRepository.observeProfile()\n) { items, theme, profile ->\n    HomeState(items = items, theme = theme, profile = profile)\n}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), HomeState())\n```\n\n### Flow Operators\n\n```kotlin\n\u002F\u002F Debounce search input\nsearchQuery\n    .debounce(300)\n    .distinctUntilChanged()\n    .flatMapLatest { query -> repository.search(query) }\n    .catch { emit(emptyList()) }\n    .collect { results -> _state.update { it.copy(results = results) } }\n\n\u002F\u002F Retry with exponential backoff\nfun fetchWithRetry(): Flow\u003CData> = flow { emit(api.fetch()) }\n    .retryWhen { cause, attempt ->\n        if (cause is IOException && attempt \u003C 3) {\n            delay(1000L * (1 shl attempt.toInt()))\n            true\n        } else {\n            false\n        }\n    }\n```\n\n### SharedFlow for One-Time Events\n\n```kotlin\nclass ItemListViewModel : ViewModel() {\n    private val _effects = MutableSharedFlow\u003CEffect>()\n    val effects: SharedFlow\u003CEffect> = _effects.asSharedFlow()\n\n    sealed interface Effect {\n        data class ShowSnackbar(val message: String) : Effect\n        data class NavigateTo(val route: String) : Effect\n    }\n\n    private fun deleteItem(id: String) {\n        viewModelScope.launch {\n            repository.delete(id)\n            _effects.emit(Effect.ShowSnackbar(\"Item deleted\"))\n        }\n    }\n}\n\n\u002F\u002F Collect in Composable\nLaunchedEffect(Unit) {\n    viewModel.effects.collect { effect ->\n        when (effect) {\n            is Effect.ShowSnackbar -> snackbarHostState.showSnackbar(effect.message)\n            is Effect.NavigateTo -> navController.navigate(effect.route)\n        }\n    }\n}\n```\n\n## Dispatchers\n\n```kotlin\n\u002F\u002F CPU-intensive work\nwithContext(Dispatchers.Default) { parseJson(largePayload) }\n\n\u002F\u002F IO-bound work\nwithContext(Dispatchers.IO) { database.query() }\n\n\u002F\u002F Main thread (UI) — default in viewModelScope\nwithContext(Dispatchers.Main) { updateUi() }\n```\n\nIn KMP, use `Dispatchers.Default` and `Dispatchers.Main` (available on all platforms). `Dispatchers.IO` is JVM\u002FAndroid only — use `Dispatchers.Default` on other platforms or provide via DI.\n\n## Cancellation\n\n### Cooperative Cancellation\n\nLong-running loops must check for cancellation:\n\n```kotlin\nsuspend fun processItems(items: List\u003CItem>) = coroutineScope {\n    for (item in items) {\n        ensureActive()  \u002F\u002F throws CancellationException if cancelled\n        process(item)\n    }\n}\n```\n\n### Cleanup with try\u002Ffinally\n\n```kotlin\nviewModelScope.launch {\n    try {\n        _state.update { it.copy(isLoading = true) }\n        val data = repository.fetch()\n        _state.update { it.copy(data = data) }\n    } finally {\n        _state.update { it.copy(isLoading = false) }  \u002F\u002F always runs, even on cancellation\n    }\n}\n```\n\n## Testing\n\n### Testing StateFlow with Turbine\n\n```kotlin\n@Test\nfun `search updates item list`() = runTest {\n    val fakeRepository = FakeItemRepository().apply { emit(testItems) }\n    val viewModel = ItemListViewModel(GetItemsUseCase(fakeRepository))\n\n    viewModel.state.test {\n        assertEquals(ItemListState(), awaitItem())  \u002F\u002F initial\n\n        viewModel.onSearch(\"query\")\n        val loading = awaitItem()\n        assertTrue(loading.isLoading)\n\n        val loaded = awaitItem()\n        assertFalse(loaded.isLoading)\n        assertEquals(1, loaded.items.size)\n    }\n}\n```\n\n### Testing with TestDispatcher\n\n```kotlin\n@Test\nfun `parallel load completes correctly`() = runTest {\n    val viewModel = DashboardViewModel(\n        itemRepo = FakeItemRepo(),\n        statsRepo = FakeStatsRepo()\n    )\n\n    viewModel.load()\n    advanceUntilIdle()\n\n    val state = viewModel.state.value\n    assertNotNull(state.items)\n    assertNotNull(state.stats)\n}\n```\n\n### Faking Flows\n\n```kotlin\nclass FakeItemRepository : ItemRepository {\n    private val _items = MutableStateFlow\u003CList\u003CItem>>(emptyList())\n\n    override fun observeItems(): Flow\u003CList\u003CItem>> = _items\n\n    fun emit(items: List\u003CItem>) { _items.value = items }\n\n    override suspend fun getItemsByCategory(category: String): Result\u003CList\u003CItem>> {\n        return Result.success(_items.value.filter { it.category == category })\n    }\n}\n```\n\n## Anti-Patterns to Avoid\n\n- Using `GlobalScope` — leaks coroutines, no structured cancellation\n- Collecting Flows in `init {}` without a scope — use `viewModelScope.launch`\n- Using `MutableStateFlow` with mutable collections — always use immutable copies: `_state.update { it.copy(list = it.list + newItem) }`\n- Catching `CancellationException` — let it propagate for proper cancellation\n- Using `flowOn(Dispatchers.Main)` to collect — collection dispatcher is the caller's dispatcher\n- Creating `Flow` in `@Composable` without `remember` — recreates the flow every recomposition\n\n## References\n\nSee skill: `compose-multiplatform-patterns` for UI consumption of Flows.\nSee skill: `android-clean-architecture` for where coroutines fit in layers.\n",{"name":5,"origin":24,"description":7},"ECC","main","481dcd7dd2e288b9d627a2bd017db70e64e6c6fa","core\u002Fskills\u002Fkotlin-coroutines-flows",2,"https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI","https:\u002F\u002Fyana.vutam.link\u002F","https:\u002F\u002Fgithub.com\u002FHoronomos-laps","https:\u002F\u002Fyana.vutam.link","An open-source governed runtime & execution environment for multi-agent AI systems.","2026-11-14 13:24:09",{"source":8,"skillName":5,"commands":36,"prompt":46,"zipAvailable":47},[37,40,43],{"tool":38,"command":39},"npx","npx skills add Horonomos-laps\u002FYana-AI --skill kotlin-coroutines-flows",{"tool":41,"command":42},"bunx","bunx skills add Horonomos-laps\u002FYana-AI --skill kotlin-coroutines-flows",{"tool":44,"command":45},"pnpm","pnpm dlx skills add Horonomos-laps\u002FYana-AI --skill kotlin-coroutines-flows","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fkotlin-coroutines-flows\u002FSKILL.md",true,[],[50,58,65,73,81,89],{"skillNo":51,"name":52,"nameZh":6,"description":53,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":54,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":19},"01M735GKET5YVYKAY62W2P5YXB","openai--sentry--sentry","Use when the user asks to inspect Sentry issues or events, summarize recent production errors, or pull basic Sentry health data via the Sentry API; perform read-only queries with the bundled script and require `SENTRY_AUTH_TOKEN`.","MIT","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fopenai--sentry--sentry\u002FSKILL.md",[],[],{"skillNo":59,"name":60,"nameZh":6,"description":61,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":62,"categories":63,"keywords":64,"publishedAt":19},"01M73DCAP83T17HY7SMGK7MGFE","ito-basket-compare","Compare Itô prediction-market baskets against a user's knowledge base, portfolio notes, financial context, watchlist, or research thesis. Use for read-only basket comparison and gap analysis without investment advice or live trading.","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fito-basket-compare\u002FSKILL.md",[],[],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":69,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":19},"01M734CYEMZFDR3KH6SW0JP8TD","implementing-network-traffic-baselining","Build network traffic baselines from NetFlow\u002FIPFIX data using Python pandas for statistical analysis, z-score anomaly detection, and hourly\u002Fdaily traffic pattern profiling","https:\u002F\u002Fgithub.com\u002Fyanacuti1121\u002FYana-AI\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fimplementing-network-traffic-baselining\u002FLICENSE","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fimplementing-network-traffic-baselining\u002FSKILL.md",[],[],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":77,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":19},"01M73ASZ6NJRJM44Z2P84NGQ3Q","detecting-evasion-techniques-in-endpoint-logs","Detects defense evasion techniques used by adversaries in endpoint logs including log tampering, timestomping, process injection, and security tool disabling. Use when investigating suspicious endpoint behavior, building detection rules for evasion tactics, or conducting threat hunting for stealthy adversary activity. Activates for requests involving evasion detection, defense evasion analysis, log tampering detection, or MITRE ATT&CK TA0005.","https:\u002F\u002Fgithub.com\u002Fyanacuti1121\u002FYana-AI\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fdetecting-evasion-techniques-in-endpoint-logs\u002FLICENSE","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fdetecting-evasion-techniques-in-endpoint-logs\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":85,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M734AFNXD06Z78QRK0VKGT7Q","implementing-microsegmentation-with-guardicore","Implementing microsegmentation using Akamai Guardicore Segmentation to map application dependencies, create granular network policies, visualize east-west traffic flows, and enforce least-privilege communication between workloads across data centers and cloud.","https:\u002F\u002Fgithub.com\u002Fyanacuti1121\u002FYana-AI\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fimplementing-microsegmentation-with-guardicore\u002FLICENSE","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fimplementing-microsegmentation-with-guardicore\u002FSKILL.md",[],[],{"skillNo":90,"name":91,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":19},"01M736TK27QMCXK0DVCH25SJN5","ramdisk-tmpfs-patterns","https:\u002F\u002Fgithub.com\u002FHoronomos-laps\u002FYana-AI\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Framdisk-tmpfs-patterns\u002FSKILL.md",[],[]]