Skip to content
Skills Library
AI & agents · Writing

session-memory

/session-memory

Maintains a structured running-notes document during long work sessions. Use when the user says "session notes", "update notes", "start session notes", "show session notes", or when you recognize the current session has accumulated enough state (decisions, corrections, files touched, errors) that it risks being lost under context pressure. Stores notes as a procedure memory tagged [session-memory, active] so they survive container death within the same session thread.

Licence
MIT
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Maintains a structured running-notes document during long work sessions. Use when the user says "session notes", "update notes", "start session notes", "show session notes", or when you recognize the current session has accumulated enough state (decisions, corrections, files touched, errors) that it risks being lost under context pressure. Stores notes as a procedure memory tagged [session-memory, active] so they survive container death within the same session thread.

Triggers from the description

session notesupdate notesstart session notesshow session notes
Original author description

Maintains a structured running-notes document during long work sessions. Use when the user says "session notes", "update notes", "start session notes", "show session notes", or when you recognize the current session has accumulated enough state (decisions, corrections, files touched, errors) that it risks being lost under context pressure. Stores notes as a procedure memory tagged [session-memory, active] so they survive container death within the same session thread.

How it works

  1. When to Use
  2. Template (Fixed Sections)
  3. Storage
  4. Update Discipline
  5. Budget
  6. Surface to User
  7. Invariants
  8. Related
Original SKILL.md headings · 148 lines, 833 words
SKILL.md preview
---
name: session-memory
description: Maintains a structured running-notes document during long work sessions. Use when the user says "session notes", "update notes", "start session notes", "show session notes", or when you recognize the current session has accumulated enough state (decisions, corrections, files touched, errors) that it risks being lost under context pressure. Stores notes as a procedure memory tagged [session-memory, active] so they survive container death within the same session thread.
metadata:
  version: 0.1.0
---

# Session Memory - Running Notes

Maintain a single structured markdown document that tracks what is happening
**right now** in the current work session. This is within-session continuity,
distinct from `remember()` (cross-session semantic memory) and `stash`
(coarse checkpoint).

## When to Use

Invoke on any of these triggers:

- User says "session notes", "update notes", "start session notes",
  "show session notes", "note the session", "write it down"
- User indicates they want continuity across context compression:
  "before you forget", "write that down", "for when context gets compressed"
- You have independently completed a meaningful block of work (file edits,
  a bugfix, a design choice, a reversal after correction) and no note has
  been updated for a while

Do NOT invoke for:

- One-off answers with no follow-up
- Cross-session persistence — that's `remember()`
- Coarse checkpoints intended for another session to resume — that's `stash`

## Template (Fixed Sections)

Every session note uses exactly these sections, in this order, with these
headers. **Preserve the structure on every update. Never rename or reorder
sections.** Update the *content* within sections; leave empty sections present
with a single `_(nothing yet)_` placeholder.

```markdown
# Session: {short title, 3-8 words, derived from the initial task}

## Current State
_What is actively being worked on right now. Explicit next step._

## Task Specification
_What the user originally asked for. Constraints, acceptance criteria,
design decisions that framed the work._

## Files and Functions
_Important paths touched or referenced, one per line, with a one-line
note on what they contain and why they matter._

## Errors & Corrections
_Errors encountered and how they were fixed. User corrections to my
approach — these have priority over routine progress entries._

## Key Decisions
_Choices made during the session with their rationale. One bullet per
decision. Lead with the choice, then the why._

## Worklog
_Terse, append-only, chronological. One line per attempt or step.
Prefix with ✓ (done), ✗ (failed), → (in progress), or ↺ (reverted)._
```

## Storage

Persist as a `procedure` memory via the `remembering` skill, so notes
survive container death within the session thread.

```python
from remembering.scripts import remember, recall, supersede

# First write in a session: create the memory
note_id = remember(
    note_markdown,
    "procedure",
    tags=["session-memory", "active"],
    priority=1,
)

# Subsequent updates: find the active note and supersede it
existing = recall(tags_all=["session-memory", "active"], n=1)
if existing:
    note_id = supersede(existing[0].id, updated_markdown, "procedure",
                        tags=["session-memory", "active"], priority=1)
```

**Session boundary:** when the user says "session done", "wrap up",
"end session", or the conversation is clearly winding down, retag the
active note from `active` to `archived` by superseding it with the same
body and `tags=["session-memory", "archived"]`.

One note is active at a time. If `recall(tags_all=["session-memory",
"active"])` returns more than one, the oldest is stale — archive it before
updating the current one.

## Update Discipline

On each invocation:

1. **Read the existing note** (if any) via `recall(tags_all=["session-memory",
   "active"], n=1)`. Work from its current body — do not regenerate from
   scratch.
2. **Update in place.** Edit the relevant sections; append to `## Worklog`.
   Do not drop prior content unless it is now wrong (then move the correction
   to `## Errors & Corrections`).
3. **Prioritize user corrections.** When the user pushes back or corrects an
   approach, that goes into `## Errors & Corrections` *before* other updates.
4. **Deduplicate against stash and explicit memories.** If an item is already
   captured in a stash or a `remember()` call, reference it by ID rather
   than restating. Notes are *supplementary*, not duplicative.
5. **Supersede, don't append.** Write the full updated document back via
   `supersede()`. This keeps exactly one active note per session.

## Budget

Target ~12K tokens for the note document. Prefer concise phrasing, but do
not truncate substantive content to hit the target — trigger
`## Key Decisions` consolidation (collapse related bullets) before cutting.
If the document exceeds ~20K tokens, compress `## Worklog` first (merge
consecutive ✓ entries into a single summary line, keep corrections and
decisions intact).

*Rationale: we run on 200K–1M context models, so the original 2K budget
from the issue spec was over-constrained. 12K matches Claude Code's
upstream design and leaves ample room for the surrounding conversation.*

## Surface to User

When the user asks to "show session notes", print the current note body
verbatim in a fenced code block. Do not paraphrase.

When updating silently (you triggered it yourself), confirm with a single
line: `Updated session notes (note id: <short-id>).` Do not dump the full
body unsolicited.

## Invariants

- Section headers and order are fixed. Updates change content, not structure.
- User corrections take priority over routine progress in ordering and detail.
- Notes do not duplicate what is already in stash or explicit memories.
- Manual invocation always works. Automatic triggers are a convenience, not
  a requirement.
- Exactly one `session-memory + active` memory exists per session. Stale
  actives are archived, not left dangling.

## Related

- `remembering` — cross-session memory store (where these notes persist)
- stash-resume-protocol (ops) — coarse session checkpoints
- context-hygiene (ops) — when and what to offload from context
Files in this package (2)
  • CHANGELOG.md 1 KB
  • SKILL.md 6 KB

Versions

RepositoryScoreLicence
This page · oaustegard/claude-skills100MIT
yo-steven/skills-exploration-20260522100Apache-2.0
major7apps/pensyve90Apache-2.0
major7apps/pensyve90Apache-2.0
major7apps/pensyve90Apache-2.0

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 26b01aa3a08b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100shodh-memory
    Persistent memory system for AI agents. Use this skill to remember context across conversations, recall relevant information, and build long-term knowledge. Activate when you need to store decisions, learnings, errors, or context that should persist beyond the current session.
  • 100cross-session-memory
    Use when you need to recover context, decisions, or artifacts across multiple Copilot CLI sessions — search prior session history and resume with the right files, notes, and state.
  • 100memory-update
    Scan agent's session-history transcripts for save-worthy signals (corrections, preferences, decisions, references), propose and write auto-memory files with valid frontmatter and MEMORY.md entry. Use when the user says "save this to memory", "remember that", or "scan this session for memories".
  • 100dump
    Consolidate the current session's progress into the project's auto-memory directory — the "log everything, update state, prepare for resumption" drill. Use when the user says "log everything", "checkpoint", "save progress", "update memory", "dump state", or autonomously when a…
  • 100session-state
    Maintain SESSION-STATE.md, the durable within-session memory that survives context compaction. Use when a constraint, settled decision, existing-infrastructure (survey) finding, or open thread must persist across a long session so it is not re-derived or re-litigated. Triggers…
  • 100claude-mem
    Persistent filesystem memory across sessions — maintains memory/ with decisions.md, context.md, glossary.md and sessions/YYYY-MM-DD.md, loads and summarizes state at session start, appends decisions and open threads at session end, compacts monthly, and refuses secrets and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.