# Plur Session End

> Extract durable learnings at the end of a session. Saves corrections, preferences, and codebase patterns as engrams — nothing ephemeral, nothing sensitive.

- Skill: `plur-ai/plur-session-end` (Agent Skill)
- Install (CLI): `npx skillmds@latest add plur-ai/plur-session-end`
- Raw SKILL.md: https://api.skillmd.com/api/skills/plur-ai/plur-session-end/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: plur-ai (https://skillmd.com/u/plur-ai)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/plur-ai/plur-session-end

---


# PLUR Session End

Run this at the end of a conversation to extract what is worth remembering.

PLUR stores durable knowledge — corrections, conventions, preferences, decisions. It does not store session logs, one-off status, or anything that will be irrelevant next week. This skill enforces that discipline.

## When to Use

- The user says "wrap up", "end session", "we're done", or similar
- The conversation is winding down after completing a task
- You want to record what you learned before the context window closes

## Procedure

### Step 1 — Identify learning candidates

Scan the conversation for:

| Category | Examples |
|----------|---------|
| **Corrections** | "No, the API returns snake_case" / "Don't use X, use Y" |
| **Preferences** | "Always run lint before committing" / "User prefers concise explanations" |
| **Codebase conventions** | "This project uses repository pattern" / "Tests live in `__tests__/`" |
| **Decisions** | "We chose PostgreSQL for ACID compliance" |
| **Gotchas** | "The staging env needs `NODE_ENV=staging`, not `production`" |
| **Terminology** | "They call it a 'slot' not a 'channel'" |

### Step 2 — Filter ruthlessly

Skip:

- Anything already obvious from reading the codebase
- Session-specific state ("we're working on the login page right now")
- One-off status ("the build was red this morning")
- Anything you are not confident about
- Secrets, credentials, API keys — never

### Step 3 — Write each learning as a durable assertion

Format: a single clear statement that will make sense to a future agent with no session context.

Good: `"The publish script requires npm 2FA — always run 'npm publish' interactively, never from CI."`

Bad: `"We talked about the publish issue."`

### Step 4 — Assign metadata

For each learning, determine:

- `type`: `correction` | `preference` | `convention` | `decision` | `gotcha` | `fact`
- `domain`: the project, library, or topic area (e.g., `"plur"`, `"typescript"`, `"project:acme"`)
- `scope`: the scope of applicability (e.g., `"global"`, `"project:acme"`)
- `tags`: 2–5 descriptive tags

### Step 5 — Save

If `plur_learn` is available:

```
plur_learn(statement, { type, domain, scope, tags })
```

Call once per learning. Do not batch into one call — separate engrams decay and strengthen independently.

If `plur_session_end` is available, pass learnings as `engram_suggestions` for batch review.

## Quality bar

Fewer, stronger engrams beat many weak ones.

- Prefer **no engram** over a vague one
- One sentence per engram — if you need two sentences, split it into two engrams
- If you're unsure whether something is reusable, skip it

## What a good wrap-up looks like

```
Session learnings saved (3 engrams):

1. [correction] The API returns timestamps in Unix seconds, not milliseconds.
   domain: project:acme | tags: api, timestamps

2. [preference] User prefers TypeScript strict mode — always enable in tsconfig.
   domain: typescript | tags: tsconfig, preferences

3. [gotcha] The staging deploy requires a manual cache bust at /admin/cache.
   domain: project:acme | tags: deploy, staging, ops
```

Keep the user-facing summary short. Show what you saved; do not narrate your reasoning.

## Integration with plur-memory

This skill pairs with `plur-memory`:

- `plur-memory` runs continuously — it injects relevant engrams at the start of each turn
- `plur-session-end` runs once — it extracts and saves what the session produced

Together they close the memory loop: inject at start, learn at end.