chaff

    1

    Find and safely reclaim disk space and memory wasted by stale build artifacts, caches, and orphaned processes.

    Free

    2 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    chaff

    Example session with this skill installed

    My disk is almost full and the machine is lagging. Check what's taking up space and give me a plan to clean up safely.

    • Read your context and instructions
    • Compiled the chaff

    I have analyzed your system's resource usage. You currently have significant disk pressure from stale build caches and orphaned git worktrees. I have generated a reclamation plan categorized by risk level.

    System Cleanup Plan (chaff_plan_8f2d)

    TargetTypeSizeTierStatus
    ~/code/old-project/node_modulesStale Cache1.2 GBTier 1 (Dead)Orphaned
    ~/code/api/.git/worktrees/feature-xGit Worktree850 MBTier 1 (Dead)Merged
    ~/.gradle/cachesBuild Cache4.5 GBTier 2 (Idle)Not used > 14 days
    NX Daemon (PID 49202)Build Process400 MBTier 2 (Idle)Inactive
    ~/code/current-app/targetBuild Output2.1 GBTier 3 (Live)[Building]

    Summary:

    • Tier 1 (Safe to reap): 2.05 GB can be reclaimed immediately.
    • Tier 2 (Requires approval): 4.9 GB of caches/daemons can be cleared.
    • Tier 3 (Skipped): 2.1 GB is currently locked by active processes.

    Next steps

    1. Run chaff_reap to clear the 2.05 GB of dead Tier 1 assets.
    2. Review the idle Gradle caches; if you don't need them, I can run chaff_clean --tier=2.
    3. Use chaff_worktrees --dirty to verify no uncommitted code exists in the feature-x worktree.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Developer machines accumulate gigabytes of dead weight that slow down builds and trigger disk space errors. This skill identifies and safely reclaims memory and disk space by targeting stray build daemons, stale caches, and abandoned worktrees without risking active work.

    What it does

    • Resource auditing identifies memory pressure and disk usage across local development environments.
    • Tiered reclamation categorizes targets into dead assets (Tier 1), idle caches (Tier 2), and active work (Tier 3) to prevent accidental data loss.
    • Build daemon management locates and terminates orphaned processes from Gradle, NX, or Node.js.
    • Safe worktree pruning detects uncommitted changes in abandoned git worktrees before suggesting removal.
    • Undoable operations moves files to a managed trash instead of immediate deletion, allowing for restoration.

    How it works

    1. Assessment via chaff_status to determine current system pressure and identify specific bottlenecks.
    2. Planning using chaff_plan to generate a list of targets and their associated tiers/sizes for user review.
    3. Safety check with chaff_worktrees to ensure no uncommitted code is lost in stale directories.
    4. Execution of chaff_reap for dead assets or chaff_clean for idle caches after explicit user confirmation.
    5. Verification by re-running status checks to report total reclaimed space and memory.

    Frameworks & tools

    Works with Node.js, Gradle, NX, git worktrees, and standard build daemons. Integrates via MCP, Claude Code plugins, or the @gulsahsarsilmaz/chaff CLI.

    Why this beats prompting it yourself

    Writing manual rm -rf commands or shell scripts risks deleting uncommitted work or active build artifacts. This skill uses a tiered safety system and built-in trash/restore functionality that basic file system prompts cannot replicate.

    Use cases

    • Fix ENOSPC "no space left on device" errors during large npm installs.
    • Clean up orphaned tsserver or gradle processes causing system lag.
    • Identify and remove forgotten git worktrees that duplicate heavy project caches.
    • Recover disk space by clearing stale build outputs from inactive projects.

    Known limitations

    Tier 3 (live work) removal is disabled over MCP and requires manual CLI execution. Requires the chaff MCP server or CLI package to be available in the environment.

    Tier 3 reclamation is restricted to CLI only. Requires @gulsahsarsilmaz/chaff package. Locked or building processes are skipped automatically.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    @gulsahsarsilmaz/chaff
    Node.js
    Git

    Permissions

    Terminal / Shell
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Chaff identifies and reclaims system resources by targeting orphaned build daemons, stale caches, and abandoned git worktrees that regular cleanup scripts often miss. It solves the common developer issue of "disk full" errors and system lag caused by lingering background processes from Node.js, Gradle, and NX.

    Chaff uses a unique tiered safety system that categorizes files by risk level and moves items to a managed trash rather than performing immediate, permanent deletion. It also includes specific checks for uncommitted git changes to ensure you never lose active work during a cleanup.

    Chaff is highly compatible with modern developer workflows, integrating seamlessly via the Model Context Protocol (MCP), Claude Code plugins, or as a standalone CLI tool via the @gulsahsarsilmaz/chaff package.

    The purchase includes the full Chaff skill set, featuring tools for auditing, planning, and execution, along with access to the MCP server configuration and CLI integration guides. You will also receive documentation on managing the tiered reclamation system for safe resource recovery.

    Yes, Chaff is specifically designed to handle complex build environments including Node.js (npm/yarn), Gradle, and NX, as well as managing memory-heavy orphaned processes like tsserver. It can detect and terminate these background daemons that often persist even after a project is closed.

    New in Workflow Automation