resume

resume is a cursor rule for coding agents from Jkudjo/oh-my-cursor. It costs 14 tokens per session (540 once invoked), scanned A, original, MIT.

A session-resume procedure that loads the latest saved checkpoint and checks whether its assumptions still match the current project and environment.

In plain words
What is it for?
Use it when returning to unfinished coding work to review what was done, identify the next steps, and detect changes that could invalidate the earlier plan.
Why use it?
It reduces the risk of continuing from outdated information, such as moved files, changed database schemas, new commits, or stopped services.

Cursor rule

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add rules/jkudjo/oh-my-cursor/resume
Clone the repo
git clone --depth 1 https://github.com/Jkudjo/oh-my-cursor

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for resume

README.md
[![agentmods](https://agentmods.dev/badge/rules/jkudjo/oh-my-cursor/resume.svg)](https://agentmods.dev/rules/jkudjo/oh-my-cursor/resume)
Your own site
<a href="https://agentmods.dev/rules/jkudjo/oh-my-cursor/resume"><img src="https://agentmods.dev/badge/rules/jkudjo/oh-my-cursor/resume.svg" alt="Measured on agentmods" height="20"></a>
Per session 14 Only the description is in the session, so the agent can decide to use it. The body loads when it is invoked.
When invoked 540 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00014 $0.00540
Opus 5 $0.00007 $0.00270
Sonnet 5 $0.00003 $0.00108
Haiku 4.5 $0.00001 $0.00054

Measured 4d ago against content hash 5fa005bcd470, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

resume scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 4d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

rules/resume.mdc · 74 lines

How it starts

The opening of the file, as written. The whole thing — 74 lines — stays where its author put it; the contents beside it link to each section on GitHub.

@resume

Trigger: At the start of a session when continuing previous work.

Protocol

Phase 1 — Load checkpoint

  1. Call get_session_context — load active modes, plans, memories, last checkpoint.
  2. Call load_checkpoint (no ID) — load the latest checkpoint.
  3. Present resume summary:
    ## Resuming session
    
    Last checkpoint: {created_at}
    Summary: {what was done}
    Next steps: {what to do now}
    Blockers: {any blockers}
    
    Active modes: {list}
    Approved plan: {plan title or "none"}
    

Phase 2 — State drift detection (critical)

Before executing anything, validate persisted assumptions against current reality.

Check each of the following and flag any that have drifted:

Codebase drift

  • Do the files referenced in the plan still exist at the same paths?
  • Have the functions/classes the plan depends on been renamed or removed?
  • Are there new commits since the checkpoint that change the affected area?

Environment drift

  • Are the environment variables the plan assumes still set?
  • Has the DB schema changed since the plan was created?
  • Are the services the plan depends on still running?

Plan validity

  • Is the approved plan still the right approach given current state?
  • Have any of the plan's assumptions been invalidated?

For each drift found, report:

⚠️ DRIFT DETECTED: {what changed}
   Was:    {what was assumed}
   Now:    {what is actually true}
   Impact: {how this affects the plan}
   Action: [update plan | re-interview | proceed with caveat]

If significant drift is found: recommend @deep-interview to re-scope before proceeding. If minor drift: note it and continue with caveats. If no drift: confirm "State validated — no drift detected."

Phase 3 — Continue

After drift check:

  • If plan is still valid: execute next steps from checkpoint
  • If plan needs update: call save_plan with updated content before proceeding
  • Restore active mode with update_mode_state if a mode was active

Rules

  • Never skip the drift check when resuming — a confidently outdated plan is worse than starting fresh.
  • Drift check must use live code/config, not memory — read the actual files.
  • If drift is detected but ignored, explicitly note the risk in the session log.

Read the full file on GitHub · 74 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 4d ago First seen · 74 lines · 14 tokens per session scan A 5fa005bcd470

Subscribe to this mod's changes

resume is a cursor rule published in the GitHub repository Jkudjo/oh-my-cursor (1 stars, last pushed 5mo ago), licensed MIT. It adds 14 tokens to every session and 540 once invoked, about $0.0001 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.