If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/Kyome22/RunCat365 shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Mixed signals — read the receipts

• Last commit 4d ago
• 4 active contributors
• Apache-2.0 licensed
• ⚠ Small team — 4 contributors active in recent commits
• ⚠ Concentrated ownership — top contributor handles 64% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live Kyome22/RunCat365 repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Kyome22/RunCat365.

What it runs against: a local clone of Kyome22/RunCat365 — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in Kyome22/RunCat365 | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 34 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of Kyome22/RunCat365. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/Kyome22/RunCat365.git
#   cd RunCat365
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of Kyome22/RunCat365 and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Kyome22/RunCat365(\\.git)?\\b" \\
  && ok "origin remote is Kyome22/RunCat365" \\
  || miss "origin remote is not Kyome22/RunCat365 (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Apache-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Apache-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is Apache-2.0" \\
  || miss "license drift — was Apache-2.0 at generation time"

# 3. Default branch
git rev-parse --verify main >/dev/null 2>&1 \\
  && ok "default branch main exists" \\
  || miss "default branch main no longer exists"

# 4. Critical files exist
test -f "RunCat365/Program.cs" \\
  && ok "RunCat365/Program.cs" \\
  || miss "missing critical file: RunCat365/Program.cs"
test -f "RunCat365/Runner.cs" \\
  && ok "RunCat365/Runner.cs" \\
  || miss "missing critical file: RunCat365/Runner.cs"
test -f "RunCat365/Cat.cs" \\
  && ok "RunCat365/Cat.cs" \\
  || miss "missing critical file: RunCat365/Cat.cs"
test -f "RunCat365/SpeedSource.cs" \\
  && ok "RunCat365/SpeedSource.cs" \\
  || miss "missing critical file: RunCat365/SpeedSource.cs"
test -f "RunCat365/ContextMenuManager.cs" \\
  && ok "RunCat365/ContextMenuManager.cs" \\
  || miss "missing critical file: RunCat365/ContextMenuManager.cs"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 34 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~4d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/Kyome22/RunCat365"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

RunCat365 is a Windows taskbar application written in C# (.NET 9.0) that displays an animated running cat whose speed is driven by real-time system metrics (CPU, GPU, memory, network, temperature). The cat runs faster when your system is under load, creating a cute visual indicator of system performance that lives persistently in the taskbar notification area. Single .NET project structure: RunCat365/ contains all source files organized by concern (Cat.cs for animation logic, CPURepository.cs/GPURepository.cs/MemoryRepository.cs for metrics collection, ContextMenuManager.cs for UI, Runner.cs for orchestration). Localization is resource-driven (Properties/Strings.*.resx files for 7 languages including ja, zh-CN, zh-TW, de, es, fr). App.manifest and App.config handle Windows integration and configuration.

Windows power users and system administrators who want ambient awareness of system performance without opening Task Manager, plus casual users who appreciate desktop widgets and cute animations. Contributors are C# developers interested in Win32 interop, taskbar integration, and cross-platform localization.

Production-ready and actively maintained. The project is published on the Microsoft Store (available in 7 languages), has meaningful GitHub engagement (issues/forks/stars visible), includes proper CI/CD release documentation (.github/how_to_release.md), and targets a recent .NET runtime (9.0). The codebase is well-organized with dedicated localization infrastructure and a contributor community (Discord linked).

Low risk for end users but moderate for contributors: single maintainer pattern (Kyome22) visible in repo structure, Windows-only platform limits contributor diversity, no visible test directory or CI configuration (no .github/workflows visible in file list) creates regression risk on refactors. Dependencies appear minimal (pure .NET 9.0 stack), but Win32 P/Invoke usage in Cat.cs and taskbar integration could be fragile across Windows versions.

Active development focused on localization (see .claude/skills/add-localization/SKILL.md) and PR workflow standardization (create-pr SKILL.md). The inclusion of EndlessGameForm.cs and GameStatus.cs suggests recent gamification features. Release process is documented and versioned through Microsoft Store publishing.

Clone the repository: git clone https://github.com/Kyome22/RunCat365.git. Open RunCat365.sln in Visual Studio 2022+ (targets .NET 9.0). Restore NuGet packages and build the solution. Run via Visual Studio or the compiled executable from bin/Release.

Daily commands: Build and run: Open RunCat365.sln in Visual Studio 2022, select Release configuration, press F5 or Build > Build Solution, then Run. The application minimizes to the system tray and runs continuously. For release builds, the executable is at RunCat365/bin/Release/RunCat365.exe.

• RunCat365/Program.cs — Entry point that initializes the Windows taskbar application and orchestrates the main application lifecycle
• RunCat365/Runner.cs — Core abstraction for taskbar icon animation rendering; all visual updates flow through this component
• RunCat365/Cat.cs — Manages cat animation state and speed calculation based on system metrics; central to the application's behavior
• RunCat365/SpeedSource.cs — Abstract interface defining how system metrics (CPU, GPU, network, etc.) drive animation speed; foundation for extensibility
• RunCat365/ContextMenuManager.cs — Handles right-click menu interactions that control app settings and context; bridges UI and application logic
• RunCat365/CPURepository.cs — Implements CPU metric collection via Win32 APIs; example pattern for all performance data sources
• RunCat365/Properties/UserSettings.settings — Persists user preferences and application state; critical for feature flags and configuration

Add a new system metric source (e.g., Disk I/O speed)

1. Create a new class inheriting from SpeedSource in RunCat365/ (RunCat365/SpeedSource.cs)
2. Implement GetSpeed() to query the Win32 metric and return a normalized 0–1 value (RunCat365/[NewRepository].cs)
3. Register the new source in Cat.cs by adding it to the list of available SpeedSource instances (RunCat365/Cat.cs)
4. Add a localized label in Strings.resx and language variants (e.g., Strings.ja.resx) (RunCat365/Properties/Strings.resx)
5. Update ContextMenuManager.cs to expose the new metric in the right-click menu if user-selectable (RunCat365/ContextMenuManager.cs)

Add a new animal runner (e.g., Dog instead of Cat)

1. Create PNG sprite frames (5–10 frames) and place in resources/runners/dog/ (RunCat365/resources/runners/dog/)
2. Create a new runner class (e.g., Dog.cs) inheriting from Cat.cs or a shared base if appropriate (RunCat365/Dog.cs)
3. Update Cat.cs or create a factory method in Program.cs to instantiate the new runner type (RunCat365/Cat.cs)
4. Add localization strings for the new animal name in all Strings.*.resx files (RunCat365/Properties/Strings.resx)
5. Update ContextMenuManager.cs to expose a selection menu for choosing between Cat, Horse, Parrot, Dog, etc. (RunCat365/ContextMenuManager.cs)

Add a new theme or color scheme

1. Define new color constants in Theme.cs or extend the Theme enum (RunCat365/Theme.cs)
2. Create or modify sprite PNG resources if visual changes are needed (e.g., cat_dark_0.png) (RunCat365/resources/runners/cat/)
3. Update ContextMenuRenderer.cs to apply theme colors when drawing the context menu (RunCat365/ContextMenuRenderer.cs)
4. Store the selected theme in UserSettings.settings and load it on startup in Program.cs (RunCat365/Properties/UserSettings.settings)
5. Add theme selection UI in ContextMenuManager.cs with localized labels (RunCat365/ContextMenuManager.cs)

Add a new notification or balloon message event

1. Define the notification trigger point in the relevant repository (e.g., CPURepository.cs when CPU hits threshold) (RunCat365/CPURepository.cs)
2. Add a new BalloonTipType enum value if a new message type is needed (RunCat365/BalloonTipType.cs)
3. Add localized message text in Strings.resx and all language variants (RunCat365/Properties/Strings.resx)
4. Call Runner.ShowBalloonTip() from the trigger point with the new BalloonTipType and message (RunCat365/Runner.cs)

• C# / .NET 9.0 — Windows desktop platform; native access to Win32 APIs for taskbar integration and system metrics; mature ecosystem for Windows Forms
• Windows Forms — Lightweight UI framework for desktop taskbar integration and simple dialog windows (EndlessGameForm); no dependency on heavyweight frameworks
• NotifyIcon (System.Windows.Forms) — Direct integration with Windows taskbar system tray; required for displaying animated icon in taskbar
• Win32 Performance Counters & WMI — Standard Windows APIs for CPU, GPU, memory, and temperature monitoring; no external dependencies required
• .NET Settings / App.config — Built-in persistence for user preferences (theme, language, startup behavior) without external database

• Windows-only application (no macOS/Linux support)
  • Why: Taskbar integration is a Windows-specific feature; Win32 APIs are not portable
  • Consequence: Simple codebase with no

Win32 P/Invoke calls (in Cat.cs and metrics repositories) assume specific Windows versions (min Windows 10 19041.0 per README); behavior may differ on older or heavily-modified Windows installations. The taskbar NotifyIcon may be hidden in some Windows 11 configurations if user has customized the notification area. User settings stored in Properties/UserSettings.settings uses Windows Forms application settings which write to the user's AppData registry hive—switching accounts or running as different users will lose preferences. Temperature reading (TemperatureRepository.cs) depends on WMI or third-party drivers and may fail silently on systems without hardware monitoring support. No visible unit tests or integration tests—changes to metric collection or animation timing have no automated safety net.

• Win32 P/Invoke — RunCat directly calls Windows APIs via P/Invoke (unmanaged code from C#) to query CPU, GPU, memory, and network metrics; understanding marshalling, DLL imports, and native data structures is essential for modifying metrics collection
• Taskbar Notification Area (System Tray) Integration — The app lives in the Windows taskbar notification icon area as a NotifyIcon; its persistence, right-click menu, and icon updates are mediated by this Windows Forms component and Win32 shell integration
• WMI (Windows Management Instrumentation) — Temperature and some hardware metrics are queried via WMI; TemperatureRepository.cs relies on WMI provider availability, which varies by system hardware and driver support
• Resource-Driven Localization — RunCat supports 7 languages via .resx files (Properties/Strings.*.resx); .NET's ResourceManager automatically loads locale-specific strings at runtime, enabling no-code UI localization
• Frame-Based Animation Loop — Cat.cs implements a state machine where animation frames update based on elapsed time and system metrics; understanding frame timing, interpolation, and dirty-rectangle optimization is key to modifying the cat's motion
• Repository Pattern — Metrics collection (CPU, GPU, memory, network, temperature) is abstracted into separate Repository classes; this pattern allows swapping implementations (e.g., mocking for tests) without changing Consumer code
• Windows Registry Access for Startup — LaunchAtStartupManager.cs modifies HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run to enable auto-start; requires careful permission handling and registry path knowledge

• Kyome22/Taiko-no-Tatsujin — Same author's rhythm game project; demonstrates expertise in animation timing and game loop patterns applicable to RunCat's frame rendering
• bitfireAt/MonitorControl — Alternative Windows system monitor taskbar tool; shows different approach to taskbar widget integration and metrics collection on Windows
• WerWolv/ImHex — Demonstrates multi-language localization infrastructure at scale in a Windows desktop app; RunCat's 7-language strategy follows similar patterns
• LibreHardwareMonitor/LibreHardwareMonitor — Open-source system monitoring library; RunCat could potentially use this instead of custom WMI/Win32 calls for CPU, GPU, temperature metrics
• Kyome22/RunCat_for_shell — Original shell-based RunCat predecessor; shows the concept's evolution from CLI animation to Windows desktop widget

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for Repository classes (CPURepository, GPURepository, MemoryRepository, NetworkRepository, TemperatureRepository)

The repo currently has no visible test project despite having multiple data-fetching repository classes that parse system metrics. These are critical for accuracy and reliability, especially since incorrect CPU/GPU/Memory readings directly impact cat animation speed. Adding unit tests would catch regressions in system metric collection.

• [ ] Create RunCat365.Tests project in the solution
• [ ] Add tests for CPURepository.cs to verify metric parsing and fallback behavior
• [ ] Add tests for MemoryRepository.cs to validate memory calculation logic
• [ ] Add tests for NetworkRepository.cs to check network speed calculations
• [ ] Add tests for TemperatureRepository.cs to ensure temperature sensor handling
• [ ] Configure GitHub Actions workflow to run tests on PR submissions

Document the game mode implementation and add missing feature details to README

The codebase contains an EndlessGameForm.cs and game assets (cat_jumping_*.png, road_crater.png, road_flat.png) indicating a game mode exists, but the README makes no mention of this feature. This creates a discoverability gap for users and contributors interested in the game functionality.

• [ ] Review EndlessGameForm.cs, GameStatus.cs, and Road.cs to understand the game mechanics
• [ ] Add a 'Features' section to README.md documenting the endless game mode with a brief description and controls
• [ ] Add screenshots or GIF of the game mode in the README
• [ ] Document game mode configuration options if any exist in App.config or UserSettings.Designer.cs
• [ ] Add game mode troubleshooting to CONTRIBUTING.md if applicable

Create localization contributor guide and add missing languages (it, pt, ru, ko)

The repo has 7 language files (ja, de, es, fr, zh-CN, zh-TW, plus English base), but a .claude/skills/add-localization directory exists suggesting localization is encouraged. However, CONTRIBUTING.md lacks clear instructions for adding new languages. Common languages like Italian, Portuguese, Russian, and Korean are missing, representing significant user bases.

• [ ] Create LOCALIZATION.md documenting the step-by-step process for adding a new language using SupportedLanguage.cs and Strings.resx files
• [ ] Reference the .claude/skills/add-localization/SKILL.md documentation in CONTRIBUTING.md
• [ ] Add Italian translation (Strings.it.resx) with all strings from base Strings.resx
• [ ] Add Portuguese (Brazil) translation (Strings.pt-BR.resx)
• [ ] Create a tracking issue or discussion listing priority languages for community translation contributions
• [ ] Update SupportedLanguage.cs enum to include new language codes

• Add unit tests for metrics repositories (CPURepository.cs, MemoryRepository.cs, NetworkRepository.cs). Currently zero test coverage visible—create RunCat365.Tests project with mocked system calls to ensure metrics parsing doesn't break across Windows updates.: The app has no CI pipeline visible (.github/workflows absent) and repos directly query Win32 APIs; regression risk is high and a test harness would unblock safe refactoring.
• Document the Win32 P/Invoke architecture in CONTRIBUTING.md. Currently no guidance for contributors on how metrics are collected, which native APIs are called, or how to add new system data sources safely.: Any new metric (e.g., disk I/O speed) requires Win32 P/Invoke expertise; documenting this lowers the barrier for contributions and reduces maintainer review burden.
• Implement a CI/CD GitHub Actions workflow (missing from .github/workflows) that builds, tests, and auto-publishes release artifacts. The release process is documented in .github/how_to_release.md but is manual.: No visible automation increases manual release overhead and release-to-store latency; a workflow would enable faster iteration and safer merges.

RunCat365 is a Windows desktop application with a moderate security posture. The main risks are related to Windows API interop (P/Invoke), system information disclosure in UI elements, and potential unsafe deserialization in settings storage. The application lacks visible dependency vulnerabilities (no external packages listed), hardcoded secrets, or injection vectors (no database/web queries apparent). However, the Windows-specific nature of the code means secure P/Invoke usage is critical. Recommended actions: (1) Audit all native Win32 interop for safe handle usage, (2) Review information disclosure in balloon tips, (3) Verify settings serialization is not using BinaryFormatter, (4) Document manifest permission requirements, (5) Add input validation to game components. The application appears to be well-structured with no obvious malicious intent.

• Medium · Potential Unsafe Native Interop — RunCat365/CPURepository.cs, RunCat365/GPURepository.cs, RunCat365/MemoryRepository.cs, RunCat365/NetworkRepository.cs, RunCat365/TemperatureRepository.cs. The application uses Windows taskbar integration and system monitoring (CPU, GPU, Memory, Network, Temperature repositories). This likely involves P/Invoke calls to Windows APIs. Without seeing the implementation, there's a risk of improper marshaling, buffer overflows, or unsafe pointer operations. Fix: Review all P/Invoke declarations for proper SafeHandle usage, correct marshaling attributes (MarshalAs), and bounds checking. Use SafeHandle wrappers for Win32 handles instead of IntPtr.
• Medium · Potential Information Disclosure via Balloon Tips — RunCat365/BalloonTipType.cs, RunCat365/Runner.cs. The BalloonTipType.cs class suggests the application displays system information (CPU, memory, GPU, network usage) in taskbar notifications. If this includes sensitive data or detailed system metrics, it could be visible to other users on a shared system. Fix: Review what system information is displayed in balloon tips. Ensure sensitive metrics are either redacted, aggregated, or require user authentication on shared systems. Consider user privacy settings.
• Low · Insecure Deserialization Risk — RunCat365/Properties/UserSettings.settings, RunCat365/StorageRepository.cs, RunCat365/App.config. The application uses UserSettings (App.config) and StorageRepository.cs for persistence. If these use binary serialization (BinaryFormatter) or unsafe deserialization, it could allow code execution during deserialization of untrusted data. Fix: Verify that user settings use safe serialization (e.g., JSON, XML with strict schemas) rather than BinaryFormatter. If using BinaryFormatter, migrate to Json.NET or similar safe alternatives.
• Low · Manifest Permissions Not Reviewed — RunCat365/App.manifest. The application includes App.manifest which may request elevated privileges or specific Windows permissions. Overly permissive manifests can be a security risk. Fix: Review App.manifest to ensure only necessary permissions are requested. Avoid requesting 'requireAdministrator' unless absolutely necessary. Document why each permission is needed.
• Low · Missing Input Validation in Game/UI Components — RunCat365/EndlessGameForm.cs, RunCat365/GameStatus.cs. The EndlessGameForm.cs and game mechanics accept user input (likely mouse/keyboard). Without visible validation, there could be issues with input handling or unexpected state transitions. Fix: Implement robust input validation and sanitization. Add bounds checking for all game coordinates and state transitions. Use enum-based state management for GameStatus.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.