Skip to content
  1. Skills at a glance
  2. Understand the code
  3. /pstack:recall

/pstack:recall

Call when needed

In one lineReads your recent chats and shared records to remind you where things stand and what's next.

When to use
You're back on an old topic after a few days, or want your progress back before a new chat.
Install with
why, unslop
Say it like this
/pstack:recall Help me remember how far we got on the export feature last week

Just asking vs. using it

The same request, typed plainly or with /pstack:recall. Here's what changes.

Just askingWith /pstack:recall
Rebuilds the story from its own chat history alone.Also searches PRs, tickets, chat channels and error tracking for the same code.
Reports status from what the chats said.Checks each PR, branch and ticket against live state with git and gh.
Reads chats from other projects too.States the scope first. The default is the active project's last 7 days.

What the document says

1 sections, about 950 words, 4 min to read. Click a section to read it.

OpeningIt rebuilds your recent context from your chats and the shared record in six steps: classify, lock the scope, mine chats in parallel, sweep the shared record, verify live state, write the brief.

  1. 1Output contractIn order: a capsule of up to 5 bullets, one tagged line per thread, up to 5 recurring problems, one next move.

See the wording worth borrowingRead the full text

Wording worth borrowing

A few sentences from the original: what each one makes the AI do, why it works, and how you can borrow it.

  1. Give a vague word a default

    "recent" is a real range, default the last 7 days

    Makes the AI
    Say "recent" and it searches the last 7 days, not whatever it guesses, like yesterday or last month.
    Why it works
    "Recent" can mean anything; a default number means the AI doesn't guess and you know how far it looked.
    Borrow it
    When you use a vague word, add a default: "'Soon' means by end of today, unless I say otherwise."
  2. Name the corner it would cut

    Never quietly turn "all" into "recent N".

    Makes the AI
    Ask for "all" and it really checks all, not just the latest few before calling it done.
    Why it works
    Naming the exact step the AI tends to quietly shrink works far better than a general "be thorough".
    Borrow it
    When you want a full check, write: "Look at all 37 files; don't sample a few and say they're all fine."
  3. Offer a fixed set of states

    A thread with no tag is not done yet, so tag it.

    Makes the AI
    Every thread is marked merged, open, in flight or not started; no "almost there".
    Why it works
    With only a few fixed tags to pick from, the AI can't blur the real state with vague words.
    Borrow it
    When you ask for status, list the options: "Tag each task 'done', 'in progress' or 'not started'."
  4. Fix what comes first

    Lead with the capsule, then the thread status, then the problems, then the next move.

    Makes the AI
    The brief opens with where things stand, details later, so two lines tell you the state.
    Why it works
    A fixed order keeps the most important part from getting buried in detail.
    Borrow it
    When you ask for a report, set the order: "Conclusion first, then the reasons, then the next step."

Full text

The SKILL.md the AI reads, as written.

descriptionReconstruct your recent working context from your own chat history, live state, and the shared record (user reports, prior fixes, incidents), then hand back a tight current-state brief. Use for 'recall my work on X', 'catch me up', 'what have I been working on', 'where did I leave off', before starting or resuming work.

Recall

Before you start or resume work, you rebuild the user's recent working context and hand back a tight capsule of where things stand now and what to do next.

Keep it tight and on-topic. Read only what the in-scope threads need, then stop.

Your context lives in two records. Your own chat history holds what you did and decided. The shared record holds everything that happened around the same code under other names: the symptoms users keep reporting, the fixes that shipped and got reverted, the errors still firing in prod. That second record is what the why skill searches, across source control, the issue tracker, chat and issue channels, long-form docs, and error tracking. A feature with a long bug tail keeps most of its story there, so don't reconstruct it from your transcripts alone.

Transcripts live where your harness keeps them. Each file is JSONL. Find the active workspace's directory for your harness. If you can't tell which harness you are, check which of these exist for this workspace:

  • Cursor: ~/.cursor/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl. <slug> is the workspace path with the leading slash dropped and each "/" turned into "-" (/Users/you/proj becomes Users-you-proj).
  • Claude Code: ~/.claude/projects/<slug>/<session-id>.jsonl. <slug> is the workspace path with every character that isn't a letter or digit turned into "-" (/Users/you/proj becomes -Users-you-proj).
  • Pi: ~/.pi/agent/sessions/--<slug>--/<timestamp>_<id>.jsonl. <slug> is the workspace path with the leading slash dropped and each "/" turned into "-" (--Users-you-proj--).
  • Codex: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl, not grouped by workspace. Keep only files whose first line has payload.cwd equal to the workspace path.
  • OpenCode: ~/.local/share/opencode/storage/. Sessions are JSON files under session/<project-id>/, with their messages under message/ and part/.
  1. Classify, then route. One specific prior chat to resume is the session-pickup playbook, not this. Turning habits into a durable skill is automate-me. A human-readable summary of your work is a different task. Recall loads working context across recent chats before you act. If the user already gave you a full state capsule (paths, branch, the change), use it and skip the mining.
  2. Lock the scope before searching. Pin the window ("recent" is a real range, default the last 7 days), the topic if named, and the workspace (default the active one. Never read another project's transcripts without being asked). State the scope back. Never quietly turn "all" into "recent N".
  3. Fan out across your chat history. Spawn parallel subagents on a fast, cheap model, each taking a slice of the corpus. Tell every subagent to order candidates by real modification time (ls -t) and never by UUID name, grep the topic first and then read only the matching chats and only their relevant regions, and skip the current chat plus obvious noise (subagent, eval, and test chats). Each returns the same schema, one block per chat: topic, the user's goal, decisions, open threads, struggles and corrections, and artifacts (PRs, tickets, branches), each citing the chat UUID. For one or two chats, skip the fan-out and search directly. The raw transcripts stay in the subagents. The main thread gets only their findings. Pick each subagent's reasoning level and fast or standard speed for the job, per the Subagents section of the poteto-mode skill.
  4. Sweep the shared record whenever the topic names a feature, file, subsystem, area, or bug. This is the default, not a judgment call, and "my work on X" does not exempt it. Hand it to the why skill's source investigators, but steer their question from "why was this built this way" to "what's the current state, what's been tried and didn't hold, and what are users still reporting". Reuse its per-source playbooks, run the investigators in parallel with the chat-history mining, and inherit its posture: one investigator per source, null results are findings, skip an unavailable MCP and say so. Fold what comes back into the brief. Skip this step only for pure activity recall with no named target ("what did I do this week"), where your own history and live state are the entire answer.
  5. Verify against live state. Take the PRs, branches, and tickets that the mining and the sweep surfaced and check them with git and gh. When the answer hinges on what an agent actually did (the tools it ran, files it read, errors it hit), read the full transcript, not just a trimmed local copy.
  6. Write the brief to the contract below. Group by thread. Stay on the named topic.

Output contract

Lead with the capsule, then the thread status, then the problems, then the next move. Deeper detail goes below or gets cut.

  • Capsule. At most 5 bullets. What this work is and where it stands overall.
  • Threads. One line each, prefixed with exactly one status tag: [merged #N], [open PR #N], [in flight <branch>], [verified, uncommitted], [reverted #N], or [planned, not started]. A thread with no tag is not done yet, so tag it.
  • Problems. At most 5, the recurring ones. Include the symptoms users keep reporting and any fix that shipped and was reverted, so the next attempt starts where the last one failed.
  • Next move. The single most useful next action, concrete.

An adjacent feature or ticket stays out unless it blocks this one. When the capsule and thread lines outgrow a screen, cut detail before you cut threads. Write the brief through the unslop skill, cite chat findings by UUID and shared-record findings by their source (PR #, ticket ID, chat permalink, error-tracker issue), and sanitize private context before any public output.

Reply: the brief, to the contract above.

Original by Lauren Tan (poteto), MIT license. Checked against the pstack mirror at 97de40d. View on GitHub

An unofficial beginner's guide to pstack, not its official docs. pstack is made by poteto; the official repo is the source of truth for commands and behavior. The original guide source is on GitHub.

Hosted by airali. Adapted from Xiaoxiaodong's MIT-licensed guide.