Session Memory Kit

    1

    Two markdown files and five habits that stop your agent from forgetting the plan, redoing finished work, or trusting a stale "tests pass" after compaction.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Session Memory Kit

    Example session with this skill installed

    I'm back. We had to restart the session. Where were we on the API refactor?

    • Read your context and instructions
    • Compiled the session memory kit

    I have read the progress.md and history.md files to restore the session state. I also verified the current repository state against the last recorded task.

    Session Restore: API Refactor

    ComponentStatusNotes
    Current GoalDecouple Auth middleware from Express routingTargeted for v2.1 compatibility
    CompletedExtracted auth.logic.ts, created unit testsTests passed in previous session
    Next ActionUpdate routes/user.ts to use the new providerBlocked by missing IAuthProvider interface
    Last DecisionUsed Dependency Injection over SingletonsReason: Testability and avoiding global state issues
    Failed PathManual token extraction in each routeReason: Resulted in 40% code duplication; reverted

    Verification Check:

    • git status confirms auth.logic.ts is staged.
    • npm test confirms 4 new tests are passing.
    • The IAuthProvider interface is indeed missing from types/index.ts.

    Next steps

    1. Define the IAuthProvider interface in src/types/auth.d.ts.
    2. Update the User route constructor to accept the new provider.
    3. Run the integration test suite to verify the handoff.

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

    About this skill

    Context compaction and session restarts often cause agents to lose track of completed tasks, leading to redundant work or hallucinated "passing" states. This skill implements a persistent state management system using two lightweight Markdown files in your project root to ensure continuity across long-running coding sessions.

    What it does

    • Persistent Progress Tracking maintains a progress.md file detailing the current goal, completed steps, and active blockers.
    • Decision Logging records architectural choices and failed experiments in history.md to prevent repetitive errors.
    • State Verification forces a check of the actual repo state (git log, test runs) after compaction instead of trusting stale context.
    • Session Handoffs generates a structured note before shutdown so the next session starts with the correct command.
    • Design Pre-approvals requires a short design plan before code execution to ensure alignment on multi-file changes.

    How it works

    1. Initialization: Create progress.md and history.md from templates if they do not exist in the root.
    2. Resumption: Read progress.md immediately after context compaction or a restart before running other commands.
    3. Observation: Update files only when a unit of work finishes, a decision is made, or a direction changes.
    4. Completion: Run the full test suite in the current context before declaring any task finished.

    Frameworks & tools

    This skill is framework-agnostic and works with any terminal-based agent like Claude Code or Cursor. It relies on standard git commands and local Markdown file manipulation.

    Why this beats prompting it yourself

    Manual prompts for "remember this" are easily lost during context window slides. This skill enforces a disk-backed source of truth that survives restarts, ensuring the agent never retries a failed approach it already discarded two hours ago.

    Use cases

    • Resuming a complex refactor after a weekend or a long break.
    • Preventing the agent from reverting a specific architectural decision during a long session.
    • Handing off a half-finished feature to a different agent or a human developer.
    • Ensuring "tests pass" claims are verified against the current environment after a summary.

    Known limitations

    Files must be kept under 180 lines to remain efficient. Requires the agent to have file system write access to the project root.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Productivity.

    Requires filesystem write access to the project root. Files must be kept under 180 lines. Relies on the agent correctly identifying compaction events.

    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 buying a skill.

    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 day ago

    Software
    GitPython

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed1 day ago

    What's inside

    Frequently Asked Questions

    This skill solves 'agent amnesia'—where AI agents forget progress after context window compaction or session restarts—by maintaining a persistent source of truth in local markdown files.

    The skill is framework-agnostic and works with any terminal-capable agent that has file system access, including Claude Code, Cursor, and Aider.

    Setup is instant; once activated, the skill automatically initializes the 'progress.md' and 'history.md' templates in your project's root directory to begin tracking state.

    Unlike standard prompts that slide out of the agent's active memory window, these disk-backed files provide a permanent 'hard drive' for your goals that persists even if the agent is completely restarted.

    Yes, the generated markdown logs serve as a structured handoff note, allowing a human developer or a different AI agent to pick up exactly where the previous session left off.

    The skill includes specialized logic to keep memory files concise (under 180 lines) to ensure the agent doesn't waste its own context window reading bloated logs.

    New in Productivity