Issue

issue: GitHub issues as resolution memory

Persist problem-solving state in GitHub issues so a later session (or a fresh context) can re-read an issue cold and continue. Each issue records the problem, a self-contained Pickup Directive, the working hypothesis, attempts, and the final resolution.

Prerequisites

• gh CLI authenticated (gh auth status).
• Inside a GitHub repo (a remote with issues enabled). If not, stop and tell the user.

Natural-language routing

Interpret intent and route:

| User says | Action | |-----------|--------| | "track this in an issue", "log this problem", "open an issue for this" | create | | "update the issue", "note progress on #N", "I found the cause" | update | | "resume issue #N", "what was I doing on #N", "pick up where I left off" | resume | | "list my memory issues", "what issues am I tracking" | list |

Default when ambiguous and a number is present → resume #N; otherwise → create.

create

1. Draft the issue body from references/issue-template.md (Problem / Pickup Directive / Hypothesis / Attempts / Resolution). Fill Problem + Pickup Directive + initial Hypothesis from the current context; leave Attempts/Resolution as stubs.
2. Confirm with the user before opening (opening an issue is outward-facing). Show the drafted title + body.
3. Create with the memory label so resume/list can filter:

``bash gh issue create --title "" --label claude-memory --body "" ` If the label does not exist, create it once: gh label create claude-memory --description "Claude resolution memory" --color BFD4F2`.

1. Report the issue number + URL.

update

1. Read before write: gh issue view --comments to load current state.
2. Append progress as a comment (never overwrite the original body):

``bash gh issue comment --body "" ``

1. When solved, append the resolution and close (confirm before closing):

``bash gh issue comment --body "Resolution: " gh issue close --reason completed ``

resume

1. Load the issue cold:

``bash gh issue view --comments ` If no number given: gh issue list --label claude-memory --state open` and ask which.

1. Reconstruct context strictly from the Pickup Directive + Hypothesis + latest comments. Do not assume prior chat memory.
2. State the recovered context back to the user, then continue the work.

list

gh issue list --label claude-memory --state open

Show number, title, and updated time.

Issue body template

The structure lives in references/issue-template.md. Read it before create so every issue is self-contained and re-readable cold. The Pickup Directive is mandatory: it is what makes the issue resumable without prior context.

Guardrails

• Read an issue (gh issue view) before commenting or closing; never blow away existing content.
• Confirm with the user before gh issue create and before gh issue close (outward-facing / state change).
• Use gh for all issue operations, not raw git; this skill never commits or pushes.
• Never modify a database; this skill only touches GitHub issues.
• Prose in English; technical terms and identifiers in English.
• Any web lookup uses Exa MCP only (websearchexa, crawling_exa); never native WebSearch/WebFetch.
• No comments inside any generated code or scripts.

Delimitation

• issue != remember: remember is an ephemeral per-session snapshot. issue is durable and GitHub-native.
• issue != brain: brain is manual Obsidian capture. issue is the repo's tracker, auto-re-read on resume.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: mirkobozzetto
• Source: mirkobozzetto/arsenal
• License: MIT

Install and usage instructions live in the source repository linked above.