Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Memory Recall

    1

    Synchronize project memory with live Git state to resume work with a high-context brief.

    $2

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Memory Recall

    Memory Recall

    Example session with this skill installed

    I'm back. Run recall to see where we left off on the authentication refactor.

    • Read your context and instructions
    • Compiled the memory recall

    I have loaded the memory files and reconciled them with the current repository state. I found that two PRs mentioned in active-tasks.md have since been merged, and I have updated the memory files accordingly.

    Project Brief: Authentication Refactor

    The project is currently mid-migration from session-based auth to JWT. The core logic is implemented in src/auth/jwt.ts, but the middleware integration is incomplete.

    Changed since last session:

    • PR #42 (Add JWT Strategy) was merged by another contributor 4 hours ago.
    • PR #45 (Update User Model) was also merged.
    • There are 3 uncommitted local changes in src/middleware/auth.ts that contradict the "Clean State" note in MEMORY.md.

    Next actions:
    1.

    Complete Middleware: The verifyToken function in auth.ts is currently a stub and needs implementation to match the new JWT strategy.
    2. Fix Unit Tests: 4 tests in tests/auth.test.ts are failing due to the change in user model schema from PR #45.
    3. Draft Documentation: Update docs/api.md to reflect the new Authorization: Bearer header requirement.

    Memory Maintenance:
    I have updated memory/active-tasks.md to mark the JWT Strategy and User Model tasks as complete.

    Next steps

    • Would you like to start by implementing the verifyToken middleware?
    • Should I run the test suite first to give you the full error logs from the model change?

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

    About this skill

    Stop wasting the first 15 minutes of every coding session trying to remember which branch you were on or which PR was failing. This skill synchronizes your persistent project memory with the actual state of your repository. It reconciles point-in-time notes against live Git data and GitHub status to provide a high-context briefing before you write a single line of code.

    What it does

    • Load memory reads all files in the project memory directory to understand past context.
    • Reconcile state compares saved notes against git status, logs, and remote branch activity.
    • Audit GitHub checks open PRs and recent releases to identify external changes since the last session.
    • Brief user generates a compact summary of project status and immediate next actions.
    • Repair stale data automatically updates outdated memory files when they contradict the repository.

    How it works

    1. Trigger the skill at the start of a session to initialize the project context.
    2. The agent reads MEMORY.md and fetches recent Git history and GitHub PR statuses.
    3. The agent identifies discrepancies between the written plan and the current code state.
    4. You receive a structured brief and can immediately begin the most relevant task.

    Frameworks & tools

    Uses standard Git commands and the gh CLI for repository introspection. It relies on a local /memory/ directory structure for persistent state storage.

    Why this beats prompting it yourself

    Manual context gathering is prone to missing upstream changes or forgetting small pending tasks buried in markdown files. This skill automates the reconciliation of documentation and reality, ensuring your agent never acts on stale information.

    Use cases

    • Resuming a complex feature build after a weekend or context switch.
    • Onboarding an agent to a repo that has evolved via external PRs since the last interaction.
    • Synchronizing project roadmaps with actual release tags and merged code.

    Known limitations

    Requires a structured /memory/ directory and MEMORY.md file to function effectively. Git and GitHub CLI must be authenticated in the environment for full reconciliation capabilities.

    Requires a /memory/ directory and MEMORY.md. Full functionality needs git and gh CLI tools configured in the environment.

    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

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Recall compares your local `MEMORY.md` notes against live Git history and GitHub PR statuses, identifying if your written plans have fallen out of sync with recent code changes or upstream merges.

    The skill requires an authenticated environment with `git` and the GitHub CLI (`gh`) installed, along with a dedicated `/memory/` directory in your project root to store persistent context.

    Recall is designed for any AI agent capable of executing shell commands and reading local files, making it compatible with most autonomous coding assistants and IDE-integrated agents.

    Recall eliminates the 'cold start' problem by automating the 15-minute manual audit of branches, PRs, and logs usually required to regain context after a break or context switch.

    You receive the core skill logic for state reconciliation, a template for the required `/memory/` directory structure, and documentation on how to integrate the briefing workflow into your agent's routine.

    While Recall can read any file, it performs best when you maintain a `MEMORY.md` file, which acts as the primary source of truth for the agent's high-level objectives and task tracking.

    New in Agents & Orchestration