Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Session Handoff: Save & Resume Claude Work

    1

    - **Environmental Snapshot**: Documents the active git branch, uncommitted changes, and validated build/test commands.

    Free

    1 useSecurity scanned
    Session Handoff: Save & Resume Claude Work

    Session Handoff: Save & Resume Claude Work

    Example session with this skill installed

    I'm hitting the context limit. Let's do a handoff for the auth refactor. Check the current git status and tests first.

    • Read your context and instructions
    • Compiled the session handoff

    I have verified the current state and generated the handoff file. git status shows 3 uncommitted files and all auth unit tests are passing.

    HANDOFF.md

    
    # Handoff — 2024-05-20 — Auth Refactor
    ## Goal
    Migrate session-based auth to JWT-based middleware with refresh token support.
    - Acceptance Criteria: Users can login, receive a 15m JWT, and use a 7d refresh token.
    
    ## Status
    - [x] JWT signing utility implementation
    - [/] Middleware integration (Started)
    - [ ] Refresh token database schema
    
    ## Decisions (and why)
    - Using RS256: Allows public key sharing for microservices to verify tokens without access to the private key.
    - 15-minute TTL: Short lifespan minimizes risk if an access token is intercepted.
    
    ## Files touched
    - `src/utils/jwt.ts` — Added sign/verify logic.
    - `src/middleware/auth.ts` — Updated to check Bearer headers.
    
    ## Commands
    - `npm test src/utils/jwt.test.ts`
    - Current branch: `feat/jwt-auth`
    - Uncommitted: `src/middleware/auth.ts`, `package.json`
    
    ## Open issues / risks
    - Potential race condition in token refresh if multiple client requests fire at once.
    
    ## Next steps (ordered, each doable in one go)
    1. Complete the try/catch block in `auth.ts` middleware.
    2. Run `npx prisma migrate dev` for the new `RefreshToken` table.
    3. Implement the `/refresh` endpoint in `auth.controller.ts`.
    
    ## Don't
    - Do not use `jsonwebtoken` library; we are using `jose` for Edge compatibility.
    

    Next steps

    1. Copy the content above into a new HANDOFF.md file at the root.
    2. Start a new session.
    3. Paste the contents of HANDOFF.md to resume exactly where we left off.
    HANDOFF.md

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

    About this skill

    Context window limits and long-running tasks often lead to lost progress and repeated work. This skill formalizes session state management by capturing the current mental model, file changes, and execution state into a portable file.

    What it does

    • State Capture: Records the high-level goal and specific acceptance criteria for the current task.
    • Progress Tracking: Catalogs exactly which files were modified and why specific architectural decisions were made.
    • Environmental Snapshot: Documents the active git branch, uncommitted changes, and validated build/test commands.
    • Roadmap Planning: Generates a sequential list of actionable next steps to eliminate cold-start friction in new sessions.
    • Failure Prevention: Explicitly lists "Dead Ends" to prevent the agent from re-attempting failed approaches.

    How it works

    1. Trigger Handoff: Invoke the skill when the context window is near capacity or ending a workday.
    2. Fact Verification: The agent runs git status and tests to ensure the documented state matches reality.
    3. Generate Document: The agent writes a structured HANDOFF.md file to the repository root.
    4. Resume Session: In a new window, the agent reads the handoff file, verifies the environment, and prompts to start the first pending step.

    Frameworks & tools

    This skill is platform-agnostic and works with any repository using git. It assumes a standard filesystem and the presence of a CLAUDE.md or similar project-level instruction file for full context.

    Why this beats prompting it yourself

    Manual handoff prompts often miss the "why" behind decisions or forget to verify if the code actually builds. This skill enforces a strict schema that includes uncommitted change tracking and verified command sequences, ensuring the next session starts with a working environment.

    Use cases

    • Context Refresh: Save state when the model reaches its context limit to start a fresh, high-performance session.
    • Shift Changes: Hand off a complex debugging task to yourself or a teammate the next morning.
    • Branch Switching: Document progress on Feature A before context-switching to a hotfix on Feature B.
    • Task Archiving: Create a record of work performed during a long-running research or refactoring spike.

    Known limitations

    Requires git for state verification. Does not store actual secrets or API keys. Best results when HANDOFF.md is deleted or archived after task completion to avoid stale context.

    Requires git for environment verification. Effectiveness depends on the agent having filesystem access to write and read the HANDOFF.md file.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed4 days ago
    Updated1 day ago

    What's inside

    Frequently Asked Questions

    This skill prevents "context drift" and lost progress by generating a structured HANDOFF.md file that captures the agent's current goals, specific file changes, and verified next steps, ensuring a seamless transition between sessions.

    The skill is platform-agnostic and works with any AI agent that has filesystem access and git capabilities, making it compatible with popular IDE extensions, CLI agents, and custom workflows.

    No complex installation is required; simply add the skill to your agent's library, and it will be ready to monitor your git status and generate handoff documents within any repository.

    Unlike manual prompts, this skill enforces a strict verification step where the agent runs git status and build commands to ensure the documented state matches the actual code reality.

    You receive the core logic for the Session Handoff skill, a standardized markdown schema for state capture, and a set of instructions for the agent to verify and resume tasks from the generated file.

    The skill captures mental models and task progress but specifically excludes secrets, API keys, or sensitive environment variables to ensure your handoff documents are safe to store in your repository.

    New in Agents & Orchestration