version
3.4.1
GitHub stars
13

Install

/plugin install agent-meta@pickled-claude-plugins

Run it inside Claude Code after adding the marketplace with /plugin marketplace add technicalpickles/pickled-claude-plugins.

Contents

Discovered from source

Skills 4

Harness Binary Spelunking

"The harness" here means whatever agent CLI you're inspecting: Claude Code, codex, opencode, pi, or any other tool that wraps an LLM in a terminal loop. The technique is the same regardless of which one you're looking at; only the recipes fork, based on how the binary was built.

Step 0: Decide your approach

Before grepping anything, figure out which situation you're in:

  • Open source, and the pinned version is tagged? Clone the source at that exact tag and read it. Fastest, most readable, no guessing at minified names. See references/source-clone.md.
  • Closed source (Claude Code today), or you want ground truth of what actually shipped? Spelunk the binary directly. Source, even when it exists, is what was committed; the binary is what's running on your machine right now.
  • Open source but the version isn't tagged yet, or you're debugging a discrepancy between source and behavior? Spelunk the binary even though source exists. "Open source" doesn't mean "skip verification."

Most investigations start at one of these two ends and only cross over if the first approach runs dry (source doesn't explain the behavior you're seeing; binary strings are too fragmented to be sure).

Identify the build and set up your workspace

If you're spelunking a binary (not reading source), run scripts/spelunk-init.sh before anything else. It resolves the binary, classifies the build, dumps strings once, and writes a manifest, all into a workspace shared by every recipe in this skill:

scripts/spelunk-init.sh claude
# Workspace ready: $TMPDIR/spelunk/claude
#   binary:      /path/to/the/real/binary
#   build type:  bun-js (bun markers: 7, rust markers: 118)
#   strings:     $TMPDIR/spelunk/claude/strings.txt
#   manifest:    $TMPDIR/spelunk/claude/manifest.txt

This exists because freelancing this step drifts fast: past investigations dumped to claude-strings.txt, then harness-strings.txt, with no per-tool suffix (so a second harness in the same session clobbers the first), and one reference file skipped the dump/reuse discipline entirely and re-ran strings on every recipe. One workspace shape, one script, no more re-deriving the path or the classification logic per investigation.

which <tool> often hands you a launcher, not the artifact (npm-installed CLIs are frequently a thin Node script that execs a platform-specific binary elsewhere). The script detects this and stops, printing the shim's contents so you can find the real spawn target by hand:

$ scripts/spelunk-init.sh codex
'/Users/<you>/.local/bin/codex' looks like a launcher/shim, not the real binary:
  a /usr/bin/env node script text executable
...
Find the spawn target above, then rerun: scripts/spelunk-init.sh codex <spawn-target-path>

$ scripts/spelunk-init.sh codex .../codex-darwin-arm64/vendor/aarch64-apple-darwin/bin/codex
Workspace ready: $TMPDIR/spelunk/codex
  build type:  rust (bun markers: 0, rust markers: 3565)

Chasing an arbitrary spawn chain is a judgment call (it varies per tool, per platform); classifying what you're holding once you have it is not, so that part is scripted. If the build type comes back unknown, file $BIN and check whether it's unbundled Node or readable source instead; see the pi note in references/source-clone.md.

Don't assume a binary is a Node bundle just because the CLI is npm-installed. Bun and Rust both ship as single Mach-O executables that npm happily distributes as "the binary." And don't assume bun/rust markers are mutually exclusive: a Bun-compiled JS bundle can embed a native Rust addon (Claude Code ships a napi/tokio one), so the script treats any Bun signal as decisive even when rust markers are also present.

General method

Once your workspace is set up, the loop is the same for every harness:

  1. Reuse the dump. spelunk-init.sh skips re-dumping if the binary hasn't changed size; every recipe below reads from its strings.txt, not a fresh strings call.
  2. Anchor on stable strings, not derived names. System-prompt openers, UI-facing error text, telemetry/event names, config-key names, .rs:line debug locations: these survive releases. Minified JS identifiers and even some struct layouts do not.
  3. Walk outward from the anchor. Grep the anchor, then read the surrounding region: awk a line range for a known window, or scripts/extract-context.sh <anchor> <file> [width] for a character window around a match anywhere in the file. Reach for the script over hand-rolling grep -aoE '.{0,N}anchor.{0,N}'; see the pitfall below for why.
  4. Filter noise, but derive the noise list per tool. Every runtime bakes in its own boilerplate (Bun's bun-internal/oniguruma, cargo's registry paths, etc.). Don't assume one tool's noise list applies to another; a quick grep -c of the suspected noise string tells you whether it's even present.

The per-build reference files below give you the concrete grep recipes for each anchor type (prompts, UI messages, function bodies, config keys). Read the one matching your build classification above.

Scripts

  • scripts/spelunk-init.sh: resolve, classify, and dump a harness binary into $TMPDIR/spelunk/<tool>/ (strings.txt + manifest.txt). Run this first.
  • scripts/extract-context.sh: print the context window around every match of an anchor, using perl instead of grep's bounded-repetition engine so it works past the widths where grep itself breaks (see Pitfalls).

Reference files

  • references/bun-js.md: Bun-compiled JS builds (Claude Code, opencode). System prompt extraction, UI-message-to-code-path, pulling minified function bodies, undocumented config keys. Covers the two tools together and calls out where they diverge (anchor scheme, noise filter, prompt fragmentation).
  • references/rust.md: Rust builds (codex). Whole-string system prompts, serde-derived config keys, .rs:line anchors, cargo-registry provenance, and what does NOT carry over from the JS recipes.
  • references/source-clone.md: version-to-git-tag mapping and clone recipe for tools that ship real source (codex, opencode, pi), plus the case (pi) where reading source beats spelunking entirely.

Shortcut: check whether someone already extracted this

Before reassembling fragments yourself, check whether someone already did the extraction and published it. For Claude Code specifically, Piebald-AI/claude-code-system-prompts tracks system/tool/agent/skill prompts as plain markdown, tagged per Claude Code version:

git clone https://github.com/Piebald-AI/claude-code-system-prompts /tmp/ccsp
git -C /tmp/ccsp tag | sort -V | tail        # versions available, e.g. v2.1.190
git -C /tmp/ccsp show v2.1.190:system-prompts/<file>.md   # a specific version's prompt
ls /tmp/ccsp/system-prompts/                 # grouped: system- tool- agent- skill- data-

It's a third-party extraction: it can lag the newest release, and it's someone else's reading, not authoritative. The binary (or source, per Step 0) on your machine is ground truth. Drop to the recipes when you need to verify a fragment, inspect a version not yet covered, or dig into anything past prompts (config keys, code paths, function bodies). The same instinct applies to other harnesses too: check for an existing extraction project before you start from scratch.

Patterns

PatternWhy
Anchor on UI strings, telemetry events, config keys, .rs:line locationsStable across releases; minified names and even struct shapes are not
Run scripts/spelunk-init.sh <tool> once per investigation, reuse its workspaceBinaries run 100-200MB+; re-running strings per grep is slow, and a shared path means every recipe agrees on where things are
Follow which through shims to the real artifact before classifyingnpm/pip installs often distribute a launcher script, not the binary
Derive the noise filter per tool instead of reusing another tool'sBun/Rust/Node each bake in different runtime boilerplate; presence isn't guaranteed
Prefer cloning tagged source over spelunking when the tool is open source and taggedFaster, more readable, no guessing at derived names
Use scripts/extract-context.sh for context windows instead of hand-rolled grep -aoE '.{0,N}...'Sidesteps the grep repetition-cap class of failure entirely (see Pitfalls)

Pitfalls

  • Assuming build type from install method. npm-installed does not mean JS bundle; codex installs via npm but ships a Rust binary. Always file the real artifact (spelunk-init.sh does this for you).
  • Trusting which at face value. It frequently returns a launcher/shim, not the artifact you want to classify.
  • Assuming bun and rust markers are mutually exclusive. A Bun-compiled JS bundle can embed a native Rust addon (Claude Code ships one via napi/tokio), so .cargo/registry hits alone don't mean the binary is a standalone Rust build. spelunk-init.sh treats any Bun-specific marker (tmp_modules/bun, oniguruma, bun-internal) as decisive over rust markers for exactly this reason.
  • Reusing one tool's noise filter on another. bun-internal noise present in Claude Code is entirely absent from opencode's Bun build; check before you filter.
  • First match for a generic UI string is rarely the only code path. Disambiguate with nearby classification tags, telemetry event names, or (in Rust) .rs:line locations.
  • Baking derived/minified names into a plan. Minified JS identifiers rotate every release. Rust struct/function names are more stable but crate-internal ones can still shift. Write down the anchor that leads you there, not the name itself.
  • Grep's bounded-repetition cap, in whichever error string your grep happens to produce. grep -aoE '.{0,500}anchor.{0,500}' fails past a certain width, but the message depends on what's actually running as grep: BSD grep says "repetition-operator operand invalid" / "maximum repetition count exceeds 255"; ugrep (a common grep shim, including via Claude Code's own file-scoped grep wrapper) says "exceeds complexity limits" at a threshold that depends on the pattern, not just the width. Same root cause, different text, so grepping the docs for one message won't surface the other. Use scripts/extract-context.sh instead of hand-rolling this grep; it does the extraction in perl, which has no such cap, and sidesteps the whole class of failure rather than tuning the width to dodge it.
  • Assuming source and shipped binary agree. Source is what was committed; the binary is what's running. When behavior doesn't match source, or the version isn't tagged yet, spelunk the binary even for open-source tools.

Real-world references

Five investigations show the technique end-to-end, across three harnesses:

  • Claude Code, sandbox internals: starting from a config key (autoAllowBashIfSandboxed), walked the Seatbelt profile generator and dynamic ripgrep deny-scan, decompiling a chain of minified functions (mu4, bu4, Vu4, _N_, Zu4, uu4) to understand how the sandbox profile is constructed.
  • Claude Code, command parser pipeline: starting from a UI string ("This command requires approval"), traced pre-parse checks, the AST walker, the known-complex set, the auto-allow gate, the interactive-vs-agent gate, and the tracked-variables store.
  • codex, Node-shim-to-Rust-binary chase: which codex resolved to a Node launcher; following the spawn target landed on a 203MB Mach-O Rust binary, confirmed via cargo-registry paths and .rs locations in the strings output.
  • codex, whole-prompt and config-key extraction: grepping you are (codex|a coding) pulled entire system-prompt constants (not fragments), and grepping approval_policy|sandbox_mode|model_reasoning_effort pulled plain serde snake_case config keys directly.
  • opencode, Bun-build comparison: confirmed the same Bun-compiled family as Claude Code, but with zero bun-internal noise, named-string function/provider wrappers (l.fn("Gemini.fromRequest"), bo.make("google")) standing in for tengu_* anchors, and a near-whole system-prompt template literal instead of Claude's fragmented assembly.

Each started from one anchor (a config key, a UI string, or a "what is this binary" question) and walked outward.

Park

Write one file a fresh session can resume from without reading this one. Park has three modes. Pick one, write that shape, do not mix.

Modes

ModeUse whenHeadingFilename
ContinuationBouncing to a new session, work continuesParked:YYYYMMDDHHMM [topic-slug].md
Close-outWork is done, capturing a record before walking awayWrapped:YYYYMMDDHHMM [topic-slug]-wrapped.md
Idle checkpointAutomated park triggered by inactivity/cache-expiry, not a user requestCheckpoint:YYYYMMDDHHMM [topic-slug]-checkpoint.md

Mode Detection

Pick one mode by checking these signals in order. Stop at the first one that resolves.

  1. Automated trigger. If the invoking prompt explicitly identifies itself as an automated/idle-triggered park (e.g. names a watchdog, cron, or "idle-triggered" rather than a person asking) → idle checkpoint. Skip every other signal below. Automated callers run headless and cannot answer a question.
  2. Explicit user hint.
    • "park, I'm done" / "wrap this up" / "park to close it out" / "park as record" → close-out
    • "park, switching sessions" / "park to continue" / "park, picking back up later" → continuation
  3. Terminal-state inference. If all major next steps are done, no blockers remain, and the current state reads as terminal → close-out. If concrete unfinished next actions exist → continuation.
  4. Ambiguity fallback. Use the AskUserQuestion tool with one A/B question:
    • Question: "Is this a close-out (work is done, archiving) or a continuation (planning to pick this up in a new session)?"
    • Options: "Close-out (record)" / "Continuation (handoff)"

Signal 3 requires an interactive caller. A headless or automated invocation must already have resolved at signal 0.

Pick once and commit. Do not switch modes mid-write.

Before Writing

  1. Resolve session ID:
    • Session ID: ${CLAUDE_SESSION_ID}
    • Claude Code fills in the value above when it loads this skill. If it is a UUID, use it.
    • Fallback: If the value above is not a UUID (another harness left it unfilled), run scripts/get-session-id.sh via Bash. If that prints nothing, use unknown.
  2. Gather the git branch, the absolute worktree path, and the identifiers the next session will check: PR numbers, task UUIDs, commit SHAs.
  3. Resolve output location, in order:
    1. Injected context has a Park vault: line and <vault>/CLAUDE.md has a ## Parking section with a Location: → that folder, relative to the vault. The section supplies only the location; filenames follow this skill.
    2. Otherwise .parkinglot/ in project root (verify it is gitignored). This also covers a vault with no ## Parking section.
  4. Get the timestamp with date +%Y%m%d%H%M. Every filename starts with it, then a single space.
  5. Resolve the file's absolute path, whichever location it lands in. Every place this skill writes [path] takes that absolute path, because a relative path only resolves from one directory and a resumed session often starts elsewhere.
  6. Find the predecessor. When this session was resumed from a park, the transcript holds an unpark <file> invocation (a typed line or an unpark skill call with a path). The file it names is the predecessor, as an absolute path. With several, take the latest. With none, there is no predecessor: skip the Supersedes line and the whole Superseding section.

Continuation Template

# Parked: [Topic]

**Parked:** [Date/time]
**Session:** [session ID]
**Branch:** [branch-name]
**Worktree:** [absolute path, if applicable]
**Supersedes:** [absolute path of the predecessor. Omit the line when there is none]

## Resume Prompt

```
unpark [path]

[Directives for the next session, at most three sentences. Omit when there are none.]
```

## Current State
- [One checkable fact per bullet, present tense]

## Key Decisions
- [Decision + why]

## Relevant Files
- path/to/file.ts (new|modified)

## Next Steps
1. [Concrete next action]
2. [Concrete next action]

## Open Questions
- [Question, and the step it blocks]

What each section holds:

  • Resume Prompt: the unpark line, then directives: how the next session behaves, which skill or playbook it starts with, who is at the keyboard and what they want. The sections below carry state and actions, so the prompt carries neither. A rule that CLAUDE.md or a rules file already loads is not a directive. With no directives, the prompt is the unpark line alone.
  • Current State: facts the next session can verify, each naming its identifier: the branch head or the uncommitted files, a PR number, a task UUID (never an integer task id, which gets reused), the test result. Unpark checks these against reality.
  • Key Decisions: choices the diff and git history cannot show, each with its reason.
  • Relevant Files: files the next session will change or must reread, marked new or modified. A file that was only read is not listed.
  • Next Steps: the one place for actions, in the order to do them. The first is what the next session does first.
  • Open Questions: only questions that block a step. Name the step. Omit the section when there are none.

Name the skill, not the raw command, for steps that have a skill. The resuming session tends to run whatever literal command the handoff spells out, and that skips the skill that would have handled it properly. So when a next step opens, edits, or comments on a PR, write "open the PR via the git:pull-request skill", not gh pr create --title ... --body .... The same goes for commits (git:commit) and working through review feedback (git:pull-feedback). Keep the step's specifics (branch, what the PR body must cover, draft vs ready). Do not hand over a copy-paste command that routes around the skill.

Session ID is load-bearing. Unpark takes its first 8 characters to find this session's devlog. Never drop the line.

Close-out Template

Use when the work is done and the user is walking away. There may be open threads, but no baton-pass.

# Wrapped: [Topic]

**Wrapped:** [Date/time]
**Session:** [session ID]
**Branch:** [branch-name]
**Worktree:** [absolute path, if applicable]
**Supersedes:** [absolute path of the predecessor. Omit the line when there is none]

## Outcome
[What got done. Past tense. Reference commits where applicable.]

## Key Decisions
- [Decision + why]

## Relevant Files
- path/to/file.ts (new|modified)

## Open Threads
[Optional. Things noticed but not done. One line each.
List follow-up candidates; don't file them in a tracker.]

A Wrapped file has to earn its place. Write one only when Key Decisions or Open Threads holds something the commits and PR do not show: a decision with its reason, a thread someone should pick up. List those two sections first. If both come out empty, or only restate the commit log, write no file. Say so in one line (Nothing to record beyond the commits, so no file written.) and stop, apart from Superseding below. Outcome alone is not a reason to write.

Close-out has no Resume Prompt and no Next Steps. If you find yourself wanting to write either, the work is probably a continuation: re-check the mode.

Idle Checkpoint Template

Written when a watchdog parks a session near its prompt-cache expiry, not when a person asked. Same shape and section rules as the continuation template, with three changes:

  • Heading # Checkpoint: [Topic].
  • **Checkpointed:** replaces **Parked:**.
  • A **Trigger:** automated (idle) line after **Worktree:**.
  • The **Supersedes:** line, when there is a predecessor, goes after **Trigger:**.

The labels tell a later park call in this same session what already happened here.

Superseding the predecessor

Runs after the new file is written, and only when step 6 found a predecessor. A close-out that wrote no file still runs it.

  1. When a file was written, confirm it exists (ls its absolute path). If it is missing, stop and leave the predecessor. When the close-out wrote no file, there is nothing to confirm: go on.
  2. Read the predecessor's first heading. Delete it only if it is Parked: or Checkpoint:. A Wrapped: record is not a handoff, and a missing file needs nothing.
  3. Delete that one file by its exact absolute path (rm "[predecessor path]"). No glob, no directory, no other file, even a similar-looking sibling.
  4. Say so in the closing message with the path: Deleted [predecessor path], the handoff this session resumed. The vault is not a git repo, so only sync history can bring it back.

The Supersedes line stays in the new file as the record of what it replaced.

After Writing

Close with one fenced block so it copies cleanly. The path appears once: inside the unpark line, or alone when there is no unpark line (close-out). Use the absolute path, with no blockquote and no quotes.

Continuation:

Parked. Resume in a new session:

```
unpark [path]
```

Close-out:

Wrapped to:

```
[path]
```

This is a close-out record. To start fresh work that builds on it, reference the file in your next session.

Idle checkpoint:

Checkpointed (automated, this session went idle). If you're still working here, ignore this. To resume elsewhere:

```
unpark [path]
```

Snapshot

Capture current session state for review without parking.

Use Cases

  • Session is getting long, want a checkpoint summary
  • Want to share progress with someone
  • Need to orient yourself on where you are

Output Format

━━━ Session Snapshot ━━━
Focus: [Current focus/goal]

Progress:
✓ [Completed item]
✓ [Completed item]
○ [In progress item]
○ [Pending item]

Key decisions:
- [Decision 1]
- [Decision 2]

Files touched:
- path/to/file.ts (new)
- path/to/other.ts (modified)

Current thread: [What we're actively discussing/working on]

Flags

--save

Write the snapshot to the parking location as a checkpoint file.

Filename: snapshot-[timestamp].md

Format when saved:

# Snapshot: [Focus]

**Captured:** [Date/time]
**Branch:** [branch-name]

## Progress
- [x] [Completed item]
- [x] [Completed item]
- [ ] [In progress item]
- [ ] [Pending item]

## Key Decisions
- [Decision 1]
- [Decision 2]

## Files Touched
- path/to/file.ts (new)
- path/to/other.ts (modified)

## Current Thread
[What we're actively discussing/working on]

Report: "Snapshot saved to [path]"

Difference from park

Aspectsnapshotpark
IntentReview progressStop work for later
OutputInline (default)Always file
Resume promptNoYes
Next stepsCurrent stateFuture direction

Unpark

Validate the handoff, report in a few lines, then keep going. Ask only when something new needs a human: drift that changes the plan, context the user added, or a question the handoff left open.

1. Find the handoff

Look in every location that applies, together: the vault (when the injected context has a Park vault: line and <vault>/CLAUDE.md has a ## Parking section with a Location:, that folder relative to the vault) and .parkinglot/ in the project root.

  • A path: use it.
  • A name or topic: match filenames and first headings. One match, use it. Several close matches, list them and ask which.
  • Nothing given: the newest Parked: or Checkpoint: file whose Branch or Worktree is in the current repo, else the newest overall. Name it in the report.
  • The user asked to see what exists: list both locations grouped as active (Parked:, Checkpoint:) and wrapped, each labeled [vault] or [.parkinglot], then run the sweep below and stop.

The first heading decides the mode, not the filename. If they disagree, trust the heading.

Sweep (listing only)

Flag an active handoff as stale when either holds:

  • its Branch is merged into the default branch (git -C <repo> branch --merged <default>; the default is origin/HEAD, else main, else master). The repo is the handoff's Worktree, else the current one.
  • it names task UUIDs and every one is done (task <uuid> status).

A handoff with no such evidence, a branch that does not exist, or a repo you cannot reach is not flagged. Age alone never flags. Wrapped: files are never flagged.

Mark each flagged line stale: <reason> in the listing. If any are flagged, ask once with AskUserQuestion (multi-select, one option per flagged file by name, plus "Keep all"; as plain text with a stop if the tool is missing). Delete exactly the files the answer selects, each by its absolute path, no globs. No answer means no delete. Say what was deleted, with paths. The vault is not a git repo, so only sync history can bring a file back. Nothing flagged: no question.

2. Go where the work is

Work from the handoff's Worktree, else the repo its Branch belongs to. Put the cd or git -C in every command, including commands you hand the user. A missing worktree is drift.

3. Validate the claims

Check what the Parked: or Checkpoint: handoff asserts against reality:

  • the branch and worktree exist, and what landed on the branch since the Parked: time
  • the key files exist
  • the PRs, tasks and commits named in Current State and Next Steps are in the state it says (gh, task, git)

In the same step as the first check, look up the devlog, even when the checks already show drift.

  1. Take the handoff's Session: id and keep the first 8 characters.
  2. grep -rlF --include='*.md' "claude-code session <id8>" <Park vault>. Notes move into topic folders, so search by that string, not by path. No Park vault: line or no hit means move on.
  3. Read the note, about 6 KB at most (the latest entries if longer). Keep what the handoff lacks: traps, gotchas, decisions the user made, corrections. Entries timestamped after the Parked: time are newer than the handoff, so check them for drift. The date is in the note's filename prefix.

4. Report, then act

The report is at most five lines, each one sentence:

  1. ✅ Handoff holds. plus what you checked (head commit, clean tree, pending tasks), or ⚠️ Drift. plus the one fact that changes the plan.
  2. 📓 plus one devlog trap, decision or correction the handoff lacks. Omit the line when there is none.
  3. ▶️ Picking up with <first next step>, then do it. On drift, one question with a recommended default instead: AskUserQuestion when available, two options, recommended first.
✅ Handoff holds. main @837b3bc, clean, tasks a1b2c3d4 and e5f6a7b8 still pending.
📓 The sync failure was a renamed container, not a timeout. The timeout was already fixed.
▶️ Picking up with the dashboard check.
⚠️ Drift. Steps 1 to 4 landed in #41 and later PRs, and the worktree is gone.
📓 The uncommitted fix shipped inside #44, so nothing was lost.
Start at step 5, or retire this handoff?
⚠️ Drift. Every step landed in #41 through #47, and 5 follow-ups remain, the main one c9d0e1f2 (the lint check skips in worktrees).
Pick up c9d0e1f2, or retire this handoff?

Nothing else goes in the report. No bullet lists, no list of what landed or what is still open (give a count and the one that matters), and no remark about a missing devlog. The user can ask for detail.

Drift is a next step that already landed, a missing branch or worktree, a decision that no longer holds, or a newer devlog entry that contradicts the handoff. A moved main or an unrelated commit goes in the ✅ line. An old handoff's age goes there too.

5. The session it came from is told for you

The agent-meta mod messages the session a Parked: or Checkpoint: handoff came from, at the moment this skill loads, when a path was given and that session is still live. Do not send that message yourself, and do not look for the session. The origin never needs a second note.

6. Extra context is where to ask

Ask one question with a default when:

  • The user added context that conflicts with or extends the handoff's next step. Say how you would merge it. Consistent, additive context needs no question.
  • An open question in the handoff blocks the first next step. Others wait until the work reaches them.
  • The next step is irreversible or outward (deploy, publish, delete, message someone). The usual rules apply. Unpark adds no gate of its own.

7. Wrapped files

A Wrapped: file is a record, not a handoff. Skip validation. Show the Outcome's first paragraph and the Open Threads as one-liners, and ask what to do with them. If the user already said, do that. New work building on the record goes through superpowers:brainstorming with the file as context. If they say it was wrapped too early, run steps 2 to 4.

Leave the handoff alone

Don't edit, rename or delete the handoff while resuming. The listing sweep is the only place unpark deletes, and only files the user selected.

Hooks 1

Sponsors

Details

Marketplace
technicalpickles/pickled-claude-plugins
Source
plugins/agent-meta
Category
Community

More from technicalpickles/pickled-claude-plugins

All 26