Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    long task manager

    1

    Persistent filesystem-based state management and background process tracking for multi-session agent tasks.

    $6.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    long task manager

    Example session with this skill installed

    I need to index 5000 markdown files for a search engine. This will take about 4 hours. Start the task and keep me updated.

    • Read your context and instructions
    • Compiled the long task manager

    I have initialized a long-term task to manage this indexing process. Since this will exceed the current session duration, I've created a persistent state file and started the indexing script in the background. ## Task Initialization: search-index-20231027 | Field | Value | | :--- | :--- | | **Task ID** | `search-index-20231027` | | **Status** | `active` | | **Background SID** | `session_8f2k9l` | | **Log File** | `/home/user/logs/indexing.log` | | **Next Action** | Poll background process and verify index.json generation | ### Task Steps 1. **Inventory Files**: `done` (5000 files found) 2. **Generate Index**: `in_progress` (started background process) 3. **Validate Metadata**: `pending` 4. **Finalize Artifacts**: `pending` **Next steps** - I will monitor the background process `session_8f2k9l` every 15 minutes. - If the session resets, tell me "resume search-index-20231027" to continue. - I will notify you once the state transitions to `done` or if a blocker is detected.

    Poll background process and verify index.json

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

    About this skill

    Stop losing progress when your agent's session resets or hits context limits. This skill provides a durable filesystem-based state machine for tasks that span hours or days. It moves task tracking out of volatile session memory and into structured JSON records, ensuring your agent can pick up exactly where it left off after a crash, timeout, or manual reset. ## What it does - **State persistence** manages JSON records in a dedicated directory to track goals, steps, and progress across session resets. - **Process lifecycle management** handles background command execution, monitoring, and recovery for long-running scripts. - **Resume protocol** provides a standardized handshake for agents to re-acquire context and verify environmental state after an interruption. - **Checkpointing system** enforces atomic updates to task files, including artifact logging and next-action instructions. ## How it works 1. **Initialize** the task using the bundled `task_state.py` helper to define the goal and discrete steps. 2. **Execute** long-running work via background terminal sessions, immediately attaching the process ID to the task state. 3. **Checkpoint** progress by updating step statuses and logging artifacts at natural intervals. 4. **Resume** interrupted work by listing active tasks, verifying existing artifacts, and executing the stored `next_action`. ## Frameworks & tools This skill requires `python3` for the state management script. It is designed to work with Unix-like and Windows environments where agents have access to `terminal` and `process` tool calls. ## Why this beats prompting it yourself Standard prompts rely on conversation history which is wiped during session resets or compressed during long tasks. This skill replaces "hopeful memory" with a concrete filesystem-based source of truth that survives process death and context clearing. ## Use cases - **Large-scale data processing** like rebuilding search indexes or crawling deep directories. - **Multi-step research** where information gathering spans multiple days. - **Codebase migrations** requiring long-running builds and validation suites. - **Background monitoring** of processes that outlive the active chat window. ## Known limitations Background processes do not survive host or gateway restarts. State files must use absolute paths to remain valid across changing session working directories.

    Background processes die on host restart. Requires absolute paths for artifacts. State files are per-profile.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill moves task tracking out of volatile conversation history and into durable JSON records on the filesystem, preventing 'amnesia' when an agent hits context limits or experiences a session timeout.

    The skill is compatible with any AI agent that has filesystem access and terminal execution capabilities, such as those running in VS Code, local development environments, or custom Python-based frameworks.

    You receive a set of optimized tool definitions for your agent, the `task_state.py` core management script, and comprehensive documentation on implementing the resume protocol.

    The skill includes a 'Process Lifecycle Management' feature that tracks PIDs (Process IDs) and logs background command output, allowing the agent to re-attach to and monitor a script that started in a previous session.

    Yes, the checkpointing system uses atomic JSON updates and absolute pathing to ensure that state files remain valid even if the agent's working directory or environment context changes between sessions.

    New in Agents & Orchestration