Kumo 0.0.15

What's Changed

Internationalization

• Replaced all hardcoded UI strings with `String(localized:)` across 25 Swift files for full i18n support

Infrastructure

• Bumped marketing version to 0.0.15

Full Changelog: 0.0.14...0.0.15

Kumo 0.0.11

What's New

• Internationalization (i18n) — Kumo now supports multiple languages.
  • Language preference available in Settings → General → Appearance
  • Supports English and Simplified Chinese
  • Language change requires app restart (standard macOS behavior)
  • All UI strings are managed via modern String Catalog ()

Artifacts

• — Apple Silicon (arm64) build
• — Update manifest for the in-app updater

Kumo 0.0.10

What's New

• feat(build): add amd64 (Intel) macOS DMG support — Intel Mac users can now install Kumo via the amd64 DMG.
• feat(about): update project links and add Telegram channel link.

Downloads

• Apple Silicon (M1/M2/M3): Kumo-macos-0.0.10-arm64.dmg
• Intel: Kumo-macos-0.0.10-amd64.dmg

Kumo 0.0.9

Kumo 0.0.9 is an incremental release focused on making advanced runtime configuration easier and safer to edit: DNS, Sniffer, TUN, System Proxy, and Sub-Store list fields now use native macOS add/remove editors instead of hand-written comma or newline-separated text.

Important: Kumo is still at an early stage. Features and data formats may continue to evolve quickly across macOS environments and runtime setups. Keep backups of important profiles and settings, and treat this build as an early preview.

What changed since 0.0.8

Compared with 0.0.8, this release focuses on three areas:

1. Reworking DNS and Sniffer runtime configuration so Kumo-owned settings can be edited, generated, and patched consistently.
2. Fixing Mihomo startup around local listener ownership so profile-provided listener ports do not conflict with Kumo's controlled mixed-port.
3. Replacing list-like text boxes with native SwiftUI list and table editors across Configure and Sub-Store surfaces.

Highlights

DNS and Sniffer configuration

DNS, Sniffer, hosts, policy, and fallback-filter settings are now represented with structured value types and generated through the runtime config builder instead of relying on users to hand-edit YAML fragments.

• Added dedicated DNS and Sniffer settings surfaces under Configure.
• Added policy value and fallback-filter value types that preserve Mihomo's single-value, multi-value, and boolean shapes.
• Added runtime YAML generation for DNS, Sniffer, hosts, nameserver policies, proxy-server nameserver policies, and fallback filters.
• Added controller patch helpers for DNS and Sniffer settings when runtime changes can be applied through Mihomo APIs.
• Documented the DNS/Sniffer split, policy value decisions, hosts placement, and restart-vs-patch behavior.

Mihomo startup and local proxy ownership

Kumo now strips profile-provided HTTP, SOCKS, redir, and tproxy listener ports before appending its controlled runtime settings.

• Kept the local proxy surface centered on Kumo's configured mixed-port.
• Passed the generated external-controller endpoint explicitly to Mihomo startup.
• Updated the service entrypoint and supervisor tests for the controller endpoint flow.
• Preserved user profile portability while preventing listener-port conflicts at startup.

Native list and table editors

List-shaped settings no longer require users to type comma-separated or newline-separated values into free-form text boxes.

• Added shared SwiftUI editors for string lists, integer lists, policy dictionaries, and fallback-filter dictionaries.
• Replaced System Proxy bypass, TUN DNS hijack, route exclusions, Sniffer ports, domain/address filters, DNS nameservers, fake-IP filters, hosts, policies, and fallback filters with native + / - editing.
• Replaced Sub-Store subscription URLs, file URLs, subscription tags, and collection tag picks with the same native list editor while keeping the backend model shape unchanged.
• Kept free-form editors only for document-like content such as PAC scripts, profile YAML, override content, Sub-Store bodies, server JSON, and process args JSON.

Release automation

Release notification automation now includes a Telegram workflow that can pin release messages for visibility.

• Added a GitHub Actions workflow for Telegram release notifications.
• Removed emoji from the Telegram release notification copy.
• Added automatic pinning for release messages in the Telegram channel.

Documentation and tests

• Updated docs/core/dns-and-sniffer-configuration.md and related ADRs for DNS/Sniffer ownership, policy values, hosts placement, and restart-vs-patch behavior.
• Updated docs/core/control-layer.md, docs/core/mihomo-runtime-controller.md, and docs/core/profiles-runtime-configuration.md for runtime settings, startup, listener ownership, and controlled top-level blocks.
• Updated docs/interfaces/macos-swiftui-interface.md to document native list/table editors for list and dictionary fields.
• Added and updated RuntimeConfigBuilder and CoreSupervisor tests for DNS/Sniffer generation, listener stripping, and Mihomo startup behavior.

Assets

• Kumo-macos-0.0.9-arm64.dmg
• latest.yml

SHA-256 for the DMG:

f540282340b1633b33d4cee188235147e89e00263226389b25a98ea4fecf45bc

Kumo 0.0.8

Kumo 0.0.8 is an incremental release focused on two practical tracks: moving the command-line surface onto a dedicated KumoCLIKit built with Swift Argument Parser, and hardening foreground shutdown so quitting or stopping the app leaves less stale proxy/runtime state behind.

Important: Kumo is still at an early stage. Features and data formats may continue to evolve quickly across macOS environments and runtime setups. Keep backups of important profiles and settings, and treat this build as an early preview.

What changed since 0.0.7

Compared with 0.0.7, this release focuses on three areas:

1. Splitting the CLI implementation into reusable KumoCLIKit commands backed by Swift Argument Parser.
2. Making app termination and runtime shutdown collect diagnostics without getting stuck.
3. Cleaning proxy node labels so inferred flag icons are not duplicated beside node names.

Highlights

CLIKit and Swift Argument Parser

The kumo command is now implemented through a dedicated KumoCLIKit package target instead of keeping nearly all command behavior in Sources/KumoCLI/main.swift.

• Added KumoCLIKit with command modules for configuration, core control, connection skill registration, logs, help, and shell completion.
• Integrated swift-argument-parser 1.7.1 while keeping Yams for YAML-backed configuration flows.
• Moved CLI runtime setup, output rendering, debug-log access, shared argument types, and skill selection helpers into focused library files.
• Kept the executable target small: Sources/KumoCLI/main.swift now delegates to the reusable CLI entrypoint.
• Added CLIKit test coverage for the refactored command entrypoint and behavior contracts.

Shutdown lifecycle hardening

Foreground shutdown now follows a log-and-continue chain so one failing cleanup step does not hide later failures or leave AppKit waiting forever.

• Renamed shutdownForegroundRuntime to shutdownActiveRuntime and changed it to return a ShutdownResult with diagnostics instead of throwing at the first failure.
• Added a synchronous networksetup fallback through SystemProxyController.disableSynchronously when the normal proxy-disable path throws.
• Added a CoreSupervisor.stop() fallback when helper-routed core stop fails.
• Added shutdown logging through os.Logger("io.kumo.KumoApp", category: "shutdown").
• Updated KumoAppDelegate.applicationShouldTerminate to race termination cleanup against a five-second timeout through a single resume gate.
• Updated KumoAppStore.prepareForTermination so proxy groups, rules, connections, providers, traffic, service status, and TUN status are refreshed even when shutdown reports diagnostics.

Proxy node label cleanup

Overview now avoids rendering the same country or region twice when a proxy node name already contains a regional-indicator emoji.

• Added ProxyCountry.displayName cleanup that strips embedded regional-indicator pairs from display labels.
• Kept the original node name intact for Mihomo API selection and search.
• Added unit coverage for regional flag display-name behavior.

Documentation and tests

• Updated docs/interfaces/cli-agent-control.md, docs/operations/persistence-logging.md, and docs/quality/testing-quality.md for the CLIKit split and Swift Argument Parser command structure.
• Updated docs/core/mihomo-runtime-controller.md for shutdownActiveRuntime, shutdown diagnostics, synchronous proxy fallback, and the AppDelegate timeout.
• Updated docs/interfaces/macos-swiftui-interface.md for flag de-duplication in Overview.
• Updated docs/operations/system-integration-permissions.md to tie foreground quit cleanup to the same system proxy disable path used at runtime.
• Added KumoCLIKitTests, four shutdown tests, and ProxyCountryTests.

Assets

• Kumo-macos-0.0.8-arm64.dmg
• latest.yml

SHA-256 for the DMG:

59ced3452aa24e3517e87f8310a1899e68b082d6992606aeaaab49bbca0f2815

Kumo 0.0.7

Kumo 0.0.7 is an incremental release focused on making routing actually take effect, making the toolbar Stop button reliably kill Mihomo, and welcoming first-run users with a guided sheet that installs the kumo CLI and the bundled Agent Skill.

Important: Kumo is still at an early stage. Features and data formats may continue to evolve quickly across macOS environments and runtime setups. Keep backups of important profiles and settings, and treat this build as an early preview.

What changed since 0.0.6

Compared with 0.0.6, this release focuses on three practical tracks:

1. Fixing routing rules not actually being applied in the generated runtime config.
2. Making the toolbar Stop reliably terminate the Mihomo core that Kumo started.
3. Adding a first-run onboarding sheet that bundles the kumo CLI install and Agent Skill registration.

Highlights

Structured runtime configuration merge

RuntimeConfigBuilder now parses profile and override YAML through Yams and merges them structurally, instead of the previous top-level text-block replacement. Routing rules from subscriptions, overrides, and Kumo-controlled keys finally compose with deterministic precedence.

• Added structured mapping-aware deep merge of profile + override YAML.
• Added Sparkle-style sequence operators +rules and rules+ for prepending and appending.
• Added Clash Verge Rev-style prepend-rules, append-rules, and delete-rules for the same effect using the upstream Mihomo key names.
• Added key! syntax to fully replace a nested mapping when overrides need to discard the base value.
• Kept Kumo-controlled keys (controller, ports, mode, geo data, TUN/DNS) as the final layer that always wins.
• Removed sequence operator keys from the final config.yaml so Mihomo only sees the resolved arrays.

Reliable core stop

CoreSupervisor no longer relies solely on the in-memory PID from state.json. It now writes and reads a work/core.pid fallback, reaps child processes with waitpid(WNOHANG), and recovers running status when the JSON state and the live process disagree.

• Added a work/core.pid file written on start and cleared on stop.
• Added waitpid(WNOHANG) based exit detection so already-exited children are not mistaken for live zombies.
• Added stop fallback that signals every PID known to Kumo (state PID + pid file) through SIGINT → SIGTERM → SIGKILL escalation.
• Added status recovery that re-marks the core as running when the PID file points at a live process even if state.json lost the PID.
• Refreshed UI store on stop so service mode, TUN, traffic, rules, connections, and providers reset to the stopped state instead of showing stale data.

First-run onboarding sheet

A native multi-step sheet greets new installs and walks users through the optional helpers. The flow is opt-in at every step and can be reopened later from Settings.

• Added an OnboardingView with Welcome / Command Line Tool / Agent Skill / Done steps gated by UserPreferences.hasCompletedOnboarding.
• Each step is composed with Liquid Glass cards (kumoGlassCard), keeping the visual language consistent with Overview and SubStore surfaces.
• Step indicator animates with snappy spring; step content transitions with a smooth fade.
• Welcome step uses the live NSApp.applicationIconImage hero so it feels like the app's own page.
• Done step shows a green hero checkmark and summary cards for what was actually installed.

CLI install from the GUI

Kumo now ships the kumo CLI inside the app bundle and offers a one-click install of /usr/local/bin/kumo through a single macOS administrator authorization prompt.

• Added CLILinkInstaller in KumoCoreKit that manages the symlink (status / install / uninstall) with the same osascript administrator flow used by the privileged helper.
• Added KumoController.cliLinkStatus(), installCLILink(), and uninstallCLILink() for both the GUI and future automation surfaces.
• Added Kumo.app/Contents/Helpers/kumo bundling so the CLI is always available next to the app. Helpers/ rather than MacOS/ because macOS volumes are case-insensitive by default and Contents/MacOS/kumo would silently overwrite the GUI main binary Contents/MacOS/Kumo.
• Added a Setup section in Settings → General with Run Setup Again and live Command Line Tool install / remove controls so the same flow is available outside onboarding.

Agent Skill registration with brand icons

The onboarding Skill step and the existing Configure surface now share the same brand iconography.

• Promoted AgentBrandIcon to KumoUIComponents and added a size parameter, so Cursor, Claude Code, Codex CLI, and Gemini CLI render their bundled brand PNGs (Generic .agents still falls back to a hierarchical SF Symbol).
• Skill rows in onboarding are fully tappable to toggle selection, with an accent-tinted glass card when selected and a chip showing Installed / Update Available.

Fixes and hardening

Fixed routing rules not taking effect

Profile and override rule sets composed unpredictably under the previous text-block merge. Structured merging plus explicit prepend/append/delete operators ensure routing rules land in the final work/config.yaml exactly as authored.

Fixed Stop sometimes leaving Mihomo running

When the JSON state PID drifted (for example after a Helper restart) or when the child process had exited but not yet been reaped, Stop could report success while the core kept running. The new pid file fallback plus waitpid reaping closes both paths.

Fixed make app shadowing the GUI binary with the CLI

The first attempt at shipping the CLI copied kumo to Contents/MacOS/kumo, which collided with the GUI's Contents/MacOS/Kumo on case-insensitive volumes and replaced the main binary. The CLI now ships under Contents/Helpers/kumo so both binaries coexist.

Documentation and tests

• Updated docs/core/profiles-runtime-configuration.md and docs/core/mihomo-runtime-controller.md for the structured merge contract, sequence operators, and the pid file + waitpid stop pipeline.
• Updated docs/operations/system-integration-permissions.md and docs/interfaces/cli-agent-control.md for the bundled CLI, the Helpers/kumo layout, and the administrator-authorized install flow.
• Updated docs/interfaces/macos-swiftui-interface.md for the onboarding sheet and Settings entries.
• Updated docs/roadmap/sparkle-parity-roadmap.md to mark structured runtime merge and graceful shutdown as implemented.
• New unit tests: CLILinkInstallerTests (7 cases), CoreSupervisorTests (3 cases), UserPreferencesTests (3 cases); expanded RuntimeConfigBuilderTests for new operators and bang replacement. Full suite passes (94 tests).

Assets

• Kumo-macos-0.0.7-arm64.dmg
• latest.yml

SHA-256 for the DMG:

ab74efca50ad76c0c21b0eba72197fa8681302bc4f97a759ead8f401138b4896

Kumo 0.0.6

Kumo 0.0.6 is an incremental release focused on making update discovery more reliable, improving the daily Overview experience, and documenting the new runtime update flow.

Important: Kumo is still at an early stage. Features and data formats may continue to evolve quickly across macOS environments and runtime setups. Keep backups of important profiles and settings, and treat this build as an early preview.

What changed since 0.0.5

Compared with 0.0.5, this release focuses on three practical tracks:

1. Replacing APNs-dependent update discovery with app-local asynchronous polling.
2. Making update notifications actionable and less noisy.
3. Improving the Overview screen for daily proxy and traffic monitoring.

Highlights

Local update polling and notifications

Kumo now checks for app updates while the app is running, without requiring APNs, push tokens, or external push infrastructure.

• Added a five-minute asynchronous release-manifest polling task owned by KumoAppStore.
• Started update polling after the SwiftUI app attaches the live store, and cancelled polling when the app terminates.
• Reused the same update-checking path for manual checks in About/Settings and background polling.
• Kept manual checks user-visible while keeping background polling quiet: transient polling failures no longer overwrite the main UI error state, and background “up to date” results do not replace user-facing status text.

Actionable update notifications

Update notifications now provide a clearer path from discovery to installation.

• Added update-available notifications with Install Now and Remind Me Later actions.
• Added download/install progress notifications with replacement-style stage text.
• Added restart-ready notifications with Restart Now.
• Routed notification actions back into the existing in-app update installer flow.

Redesigned Overview experience

The Overview screen has been reworked around daily-use visibility: current profile context, live traffic, and proxy groups are easier to scan from the main window.

• Added a proxy-node sidebar preview for the current profile while the core is stopped.
• Added live proxy group rendering when the core is running.
• Added richer Overview cards for profile, traffic, runtime state, and key actions.
• Added a rolling traffic history buffer and expanded traffic sparkline for recent throughput.
• Added proxy country detection/caching support so node lists can show region context when available.

Fixes and hardening

Fixed update discovery depending on unfinished APNs infrastructure

The previous update-notification direction registered for remote notifications, but the app did not have a complete APNs delivery path. Kumo now uses local runtime polling instead.

• Removed remote-notification registration from the app launch path.
• Removed stale APNs-oriented documentation claims.
• Documented that update discovery is app-local and does not require APNs or a push token.

Reduced update notification spam

The five-minute polling loop is throttled so users are not repeatedly interrupted for the same release.

• Update-available notifications are gated per version.
• Remind Me Later removes the visible update notification and suppresses that version for six hours.
• Newer versions are treated as fresh notification candidates.

Improved stopped-state Overview behavior

Overview no longer collapses into an empty proxy area just because the core is stopped.

• Parsed configured proxy groups from the current profile YAML for stopped-state preview.
• Kept live controller data as the source of truth once the core is running.
• Added focused tests for profile node parsing and proxy country lookup behavior.

Documentation and tests

• Added docs/operations/app-updates/ as the dedicated documentation home for app update polling, notifications, manifest checks, download verification, and installer handoff.
• Updated release management docs to focus on release artifacts while linking runtime update behavior to the new App Updates docs.
• Updated macOS SwiftUI interface docs for the new Overview and notification behavior.
• Added/updated tests for profile node parsing, proxy country matching, and proxy geo lookup.
• Verified the release build through the Makefile release artifact flow.

Assets

• Kumo-macos-0.0.6-arm64.dmg
• latest.yml

SHA-256 for the DMG:

af381b6d309624e707323e11b133277139e0ade894ffe2c20f2162c4174a702f

Kumo 0.0.5

Kumo 0.0.5 is an incremental release focused on connection observability UX, richer runtime metadata, and open-source compliance hardening.

Important: Kumo is still at an early stage. Features and data formats may continue to evolve quickly across macOS environments and runtime setups. Keep backups of important profiles and settings, and treat this build as an early preview.

What changed since 0.0.4

Compared with 0.0.4, this iteration focuses on two practical tracks:

1. Improving the connection inspection experience with app/process-aware visual context.
2. Clarifying licensing and third-party attribution for distribution readiness.

Highlights

Better Connections inspection UI

This release upgrades ConnectionsView from text-only process display to icon+metadata presentation, making it faster to identify which app owns each live connection.

• Replaced plain process labels with a dedicated process cell component.
• Added app icon rendering sourced from process path metadata when available.
• Improved process-level visual scanning in active connection lists.
• Refined related view composition in shared UI components for cleaner rendering behavior.

Richer runtime metadata propagation

Connection metadata now carries process path information through the core model and networking layers so the UI can render application identity consistently.

• Extended connection model payloads with process path support.
• Updated Mihomo controller parsing/mapping to preserve the added metadata.
• Updated runtime config integration paths affected by the new model shape.
• Added/updated core tests to validate the metadata handling path.

Overview polish and state messaging

Overview messaging and metrics layout were adjusted for clearer state feedback and more stable card presentation.

• Improved conditional state messaging based on store/runtime conditions.
• Improved metric card layout responsiveness for different window sizes.

Licensing and distribution compliance

Kumo now includes explicit AGPL-3.0 licensing and third-party notices in-repo.

• Added project LICENSE (AGPL-3.0).
• Updated README.md licensing references.
• Added docs/THIRD_PARTY_NOTICES.md for dependency attribution.

Documentation and test updates

• Updated product and interface docs to reflect new ConnectionsView behavior and metadata flow.
• Updated profiles/runtime documentation for related configuration and model changes.
• Added/updated tests covering controller parsing and runtime configuration paths touched in this iteration.

Assets

• Kumo-macos-0.0.5-arm64.dmg
• latest.yml

SHA-256 for the DMG:

1dde5eaa3d2a4631014ed5000456916ede156876fae485f018ce61f5af15c8e3

Kumo 0.0.4

Kumo 0.0.4 is a substantial early release that expands the app beyond basic Mihomo control into local Sub-Store management, agent-oriented automation, and more reliable live runtime monitoring.

Important: Kumo is still at a very early stage. Many features are experimental, may be incomplete, and are not guaranteed to work reliably across all macOS environments, Mihomo configurations, subscription formats, or automation workflows yet. Please treat this build as an early preview, keep backups of important profiles and settings, and expect behavior and data formats to change before the project is considered stable.

Highlights

Native Sub-Store integration

This release adds the first native Kumo surface for managing a bundled local Sub-Store backend.

• Added a bundled Sub-Store backend payload and local runtime preparation flow.
• Added a generated Node runtime preparation step for app and release builds, keeping the large Node sidecar out of Git while still packaging it into the built app.
• Added a native SwiftUI Sub-Store screen instead of embedding a web view.
• Added subscription and collection management surfaces with list/detail flows.
• Added on-demand advanced Sub-Store sheets for files, modules, artifacts, archives, share tokens, server settings, and backend logs.
• Added backend lifecycle controls for preparing resources, starting, stopping, and restarting Sub-Store.
• Added backend connection settings and runtime status handling so the UI can recover when resources are missing or the backend is not running.
• Added a dedicated SubStoreStore so Sub-Store state updates do not invalidate the rest of the app UI.
• Added SubStoreClient, Sub-Store content models, JSON value handling, and tests for the new API layer.
• Added profile import/refresh metadata for Sub-Store generated profiles. Profiles imported from Sub-Store now remember the original download path and refresh through the current local backend URL with Clash Meta output and cache bypassing.

Agent skill installation

Kumo now ships a bundled kumo-cli Agent Skill and provides both GUI and CLI installation paths for coding-agent workflows.

• Added an Agent Skills configuration view in the macOS app.
• Added bundled skill assets and metadata for the kumo-cli skill.
• Added support for installing skills into Cursor, Claude Code, Codex CLI, Gemini CLI, and generic .agents skill directories.
• Added global and project-scope installation where supported.
• Added status, dry-run install, install/update, and uninstall flows.
• Added non-destructive overwrite protection: existing skill directories that were not created by Kumo are not replaced unless the user explicitly allows it.
• Added kumo skills status, kumo skills install, and kumo skills uninstall CLI commands with JSON support for automation.
• Added tests covering installer behavior, target mapping, state tracking, and safety rules.

CLI and automation additions

The kumo CLI now exposes more of the shared control layer used by the macOS app.

• Added kumo substore status, prepare, start, stop, and restart commands.
• Added kumo skills ... commands for agent skill management.
• Improved start/restart behavior so the CLI can install the managed core when no usable core candidate is available.
• Extended JSON-friendly command output for the new automation surfaces.
• Updated the CLI documentation and bundled skill documentation so agents have a clearer contract for driving Kumo safely.

Fixes

Fixed live traffic getting stuck at zero

This release fixes a major runtime monitoring issue where the Overview traffic card could stop updating permanently.

Previously, the Mihomo /traffic WebSocket had no reconnect supervisor. If the stream dropped because Mihomo restarted, the controller state became stale, or a network hiccup occurred, the stream could finish and Kumo would keep showing zero traffic speeds indefinitely.

The fix adds a reusable reconnecting WebSocket supervisor for long-lived Mihomo streams.

• Traffic, logs, and memory WebSocket streams now reconnect after transient disconnects.
• Traffic gauges reset to an idle zero snapshot after an established stream drops, so the UI does not display stale speeds while reconnecting.
• The WebSocket request now sends the controller secret as a Bearer token for parity with HTTP requests.
• The traffic parser now treats Mihomo up and down as live upload/download speeds.
• The parser now treats upTotal and downTotal as cumulative totals.
• Overview now reads live traffic metrics from the dedicated traffic snapshot rather than relying on fallback behavior from connection snapshots.
• Added tests for the corrected traffic payload parsing.

Fixed macOS app icon sizing

The app icon assets were regenerated with normalized padding so Kumo appears at the expected size in Finder and DMG views.

• Fixed oversized/undersized visual appearance caused by inconsistent icon padding.
• Updated all app icon resolutions from 16px through 1024px.
• Improved consistency with surrounding macOS application icons.

Improved release build correctness

The release process now has stronger version and packaging checks.

• Added explicit VERSION validation for release artifact generation.
• Added BUILD_NUMBER support for release builds.
• The release artifact script now verifies that Kumo.app's CFBundleShortVersionString matches the requested release version before creating a DMG.
• Added a stable app bundle identifier setting to the Makefile.
• Added release build integration for preparing the Sub-Store runtime before packaging.
• Added a latest.yml manifest flow for GitHub Releases updates.
• Added release documentation for the Sub-Store runtime payload and manifest expectations.

Improved traffic management in the app store

Kumo now manages the traffic stream more deliberately from the app state layer.

• Added traffic stream lifecycle handling in KumoAppStore.
• Improved live upload/download speed propagation into Overview.
• Reduced the chance of stale traffic state after runtime changes.

Documentation and tests

• Updated macOS interface documentation for Sub-Store and Agent Skills surfaces.
• Updated CLI and agent-control documentation for substore and skills commands.
• Updated profile/runtime configuration documentation for Sub-Store generated profiles.
• Updated persistence, release, permissions, testing, and roadmap documentation to match the new runtime resources and workflows.
• Added unit coverage for Agent Skills installation.
• Added unit coverage for Sub-Store client and manager behavior.
• Added unit coverage for Mihomo traffic parsing and runtime configuration changes.

Known limitations

• This is still a very early release. Many features are not yet hardened and may fail in real-world configurations.
• Sub-Store support is new and should be considered experimental. Some subscription formats, collection workflows, modules, artifacts, or advanced backend settings may not behave as expected yet.
• Kumo's native Sub-Store UI talks directly to the bundled backend API, and that integration may change as the API surface stabilizes.
• Agent skill installation supports common directory layouts, but agent tooling conventions are still evolving and may require manual adjustment in some environments.
• Service mode, TUN handling, update installation, and system proxy behavior remain sensitive to macOS permissions and local machine state.
• Release artifacts are intended for early testing, not for production-critical networking setups.

Assets

• Kumo-macos-0.0.4-arm64.dmg
• latest.yml

SHA-256 for the DMG:

c7264b664ffc2b1ac38bd5a10178df974a3eca4c6ff8d11bd9d14f12a29c5625

0.0.3

Kumo 0.0.3 is still an early preview release. Expect rough edges, fast iteration, and possible behavior changes while the app stabilizes.

Rebuild note: the downloadable macOS package was rebuilt from the current main branch to include the agent skill installer and the latest build/version consistency fixes.

Highlights since 0.0.2

• Added the Kumo agent skill installer, including the macOS Integrations UI and kumo skills CLI commands for supported coding agents.
• Added the bundled kumo-cli agent skill resource to the app package.
• Improved release packaging so the built app version is validated against the release VERSION before DMG creation.
• Improved live traffic metric handling so overview upload/download rates are fed by the traffic snapshot stream.
• Polished macOS interactions across the main window, configuration, profiles, overview, and inspection views.
• Fixed system proxy bypass editor newline handling so bypass entries are easier to edit and preserve correctly.
• Made release artifact generation more resilient when Finder cannot automate the mounted DMG layout.

Notes

• This build is intended for early adopters who are comfortable reporting issues and updating frequently.
• Please file bugs and feedback at https://github.com/ProjectKumo/KumoApp/issues.