Durable Planning on Disk

    1

    Turn interruptions into pauses: your agent keeps a three-file ledger of plan, evidence, and journal on disk, so long-running work always resumes cleanly.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Durable Planning on Disk

    Example session with this skill installed

    I'm migrating our billing service from cron scripts to queue workers and it'll take several sessions. Set up durable planning for this: create the plan, notes, and journal files in the repo root, then start phase one by reading legacy_billing/cron/*.py and jobs/worker_pool.ts and capturing what you find. When you make any architecture choice, write down why and what you rejected. If a test or command fails, log it instead of silently retrying. Each time I come back, re-read the files before you act and tell me the current phase and next action.

    • Read your context and instructions
    • Compiled the durable planning on

    Summary

    Scaffolded the durable planning ledger in the repo root and completed Phase 1 (Understand the task). Findings and failures are now on disk, so any interruption becomes a clean resume instead of a restart.

    FileStateKey entry
    PLAN.mdPhase 2 active: Gather evidenceNext action: benchmark consumer throughput
    NOTES.md14 evidence items, every fact has file:line sourceRedis visibility timeout vs SQS 30s default
    JOURNAL.md6 entries, 2 failures loggedPermission denied on /etc/hosts → project-local override

    Decisions recorded: keep SQS over in-process worker pool (rejected: no backpressure evidence). Blocker: staging lacks queue IAM role.

    Next steps

    • Phase 2: run throughput numbers against jobs/worker_pool.ts
    • Phase 3: decision memo comparing retry/DLQ semantics per queue
    • Capture to NOTES.md after every two info-gathering steps
    • Tell you when PLAN.md moves to Phase 4 (Execute) or a blocker is added
    PLAN.md

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

    About this skill

    Long-running agent tasks often fail when the conversation window hits context limits or suffers an interruption. You lose the history of what was tried, why certain paths were rejected, and what specific evidence was found in deep sub-directories. This skill implements a filesystem-based ledger system that makes complex work resumable and auditable.

    What it does

    • State persistence: Maintains a three-file ledger (PLAN.md, NOTES.md, JOURNAL.md) in the project root to store durable state.
    • Context management: Offloads large findings and evidence to disk to prevent conversation window bloat and compression loss.
    • Decision logging: Captures rationales and rejected alternatives to prevent the agent from repeating failed strategies.
    • Session recovery: Provides a structured protocol for resuming work after pauses or context resets by reading the on-disk state.

    How it works

    1. Bootstrap: Run a shell command to initialize the markdown ledger files with structured templates.
    2. Capture: Log every meaningful discovery, command output, or decision into the appropriate file immediately.
    3. Orient: Read the head of the plan and the tail of the journal at the start of every work cycle or session.
    4. Advance: Update phase statuses and next actions in the plan as milestones are reached.

    Frameworks & tools

    This skill is platform-agnostic and uses standard POSIX shell commands like cat, sed, tail, and rg (ripgrep) for file manipulation and state inspection.

    Why this beats prompting it yourself

    Standard prompts rely on volatile LLM memory which eventually evaporates or drifts. This skill enforces a "Two-Datum Rule" and a "Three-Layer Retry Protocol" that forces the agent to document its logic on disk, ensuring you never pay for the same research twice.

    Use cases

    • Migrating complex legacy codebases across multiple files.
    • Investigating intermittent bugs that require long-term observation.
    • Performing deep market or technical research across many web sources.
    • Executing multi-step infrastructure changes that span several days.

    Known limitations

    Adds overhead to simple tasks and requires filesystem write permissions. It is not intended for one-off edits or trivial lookups.

    Adds bookkeeping overhead that is not worth it for simple questions or one-file edits. Quality depends on the agent actually updating the files; a sloppy run can leave the ledger stale.

    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 to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 26 days ago

    • Free with an Agensi account

    Requires

    vitest
    Node.js

    Permissions

    Terminal / Shell

    File Scopes

    **/*

    Reads project files and command output as evidence and writes only the three planning ledger files (PLAN.md, NOTES.md, JOURNAL.md), refusing to overwrite them without reading first; no network access is needed.

    Listed26 days ago

    What's inside

    Frequently Asked Questions

    This skill prevents agents from 'forgetting' their progress during long tasks by offloading plans and findings to a three-file markdown ledger on disk, bypassing LLM context window limits.

    The skill is platform-agnostic and works with any AI agent that has filesystem access and can execute standard shell commands like cat, sed, and ripgrep.

    You receive the proprietary prompt protocols, structured markdown templates, and the specific 'Two-Datum' and 'Three-Layer' logic used to govern how the agent manages the disk state.

    Setup is nearly instant; it involves a simple bootstrap command that initializes the PLAN, NOTES, and JOURNAL templates in your project's root directory.

    Because it relies on a physical ledger, you can simply point a new agent session at the existing files, and it will read the state to resume work exactly where the previous session left off.

    This system is designed for high-complexity, multi-step projects; for simple one-off tasks or quick edits, the overhead of maintaining the ledger may be unnecessary.

    No. It works entirely with plain markdown files in your project root plus shell commands, so it runs offline with zero credentials.

    The scaffold is idempotent: existing ledger files are detected and read before anything is written, so an in-progress plan is never overwritten.

    The skill explicitly tells the agent to skip planning files for simple questions, quick lookups, and one-off edits; it activates when work grows beyond a few steps or risks losing context.

    New in Workflow Automation

    Free