⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

close-session

awrshift@awrshift⭐ 34 stars· last commit 2d ago· 0 open issues

End-of-session ritual — audit today's patterns against accumulated memory, propose promotions, refresh MEMORY.md, and write the session handoff. Use when the user says "/memory-kit:close-session", "закрой сессию", "закрываем", "we're done for today", "wrap up".

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 34 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Multi-Agent Driven Development: you talk to one main session; it sends brief files to three window sessions, each with its own subagents; files and memory underneath

Multi-Agent Driven Development Kit

You talk to one agent. It runs the team.

Formerly Claude Memory Kit — the plugin id memory-kit and every command name stay the same for compatibility.

A plugin and a working method for Claude Code. The scarcest resource in agent-driven work is your attention, so the method spends it in one place: you talk to one agent only — the main session. It holds the whole picture, so you decide with one counterpart instead of five; it splits the work across the other sessions and their helpers. You never talk to the windows or the helpers, never relay a brief, never read their raw output: decisions, evidence and questions reach you from one place.

The team is two levels deep. You → main → three windows → their subagents.

  • Main plans the round, writes the specs, rules on every finding, accepts work on evidence, and is the only one that acts outward (a push, a PR, a reply others will see).
  • Three windows are full Claude Code sessions, not subagents — each opened by you in its own terminal, visible, with its own context, tools, hooks and memory, holding one task to its stop points.
  • Each window calls its own subagents (a builder, a reviewer, a fact-gatherer), each with an explicit model.

Why sessions, and not only subagents. A subagent lives inside its caller's session: it works in its own context and hands back a summary, it cannot ask you a question, and its permission prompts surface in the caller's terminal (Claude Code docs, subagents). A window is a session you can watch and that starts like any session — your CLAUDE.md, the hooks, this kit's memory and handoff — so it can hold a task across several stops and reviews and still survive main being cleared. Claude Code's own agent teams also run teammates as full sessions, but let you talk to any teammate directly; this method keeps you talking to main only.

What crosses each level is a file. A brief, a spec, a report, a ruling, an acceptance record — committed to the repository. Messages only point at files, five lines at most.

Who decides what. You: product scope, and money above the cap you set. Main: architecture, acceptance, every outward action. Windows: build to a spec and report; they never decide.

Memory is the foundation. Short dated notes and a handoff, as plain files in your repository, read at every start — so main, each window, and you after a day away all pick up where the work stopped after a cleared context. Dangerous commands are stopped before they run: a force push, reset --hard, a read of .env, an edit that weakens a test. Nothing becomes a rule without your yes. No database, no service, no API key. An independent project, not made or endorsed by Anthropic.

Why the method matters. In one project, in five of six pieces of work the fix made after a review reached acceptance with nobody reviewing the fix itself; checked afterwards, two of those five carried a defect serious enough to block. A small sample from one project — a reason to look at your own fixes, not a proven rate.

Version License: MIT Claude Code plugin

On this page: How it works · Install · The method · Team of sessions · What is inside · Reference · What it writes · Privacy and cost · Proof status

How it works

  1. You work as usual. When something is worth keeping, the agent writes one dated line and tells you.
  2. You close the session. It looks for patterns across days («you rejected this on four different days — make it a rule?»), writes what you approve, and leaves a handoff note.
  3. The next session starts already knowing — memory, the handoff and the list of knowledge articles are loaded by a hook.
  4. When the work outgrows one session, main runs the team: a spec file first, a brief file per window, a review of every diff, a record of what was accepted and why (below). Memory works on its own; take the team half when you hand work to helpers or run several sessions at once.

Install

Inside the repository, in Claude Code:

/plugin marketplace add awrshift/agent-memory-kit
/plugin install memory-kit@memory-kit
/memory-kit:setup

setup reads what the repository already has and proposes before writing anything; your CLAUDE.md stays yours. Git is optional. To upgrade later: claude plugin marketplace update memory-kit, then claude plugin update memory-kit@memory-kit (the full id is needed), and restart the session. Upgrades never touch your files. In a repository that never ran setup, the hooks inject one pointer line and write nothing.

The method in one screen

The method: main writes the spec file; windows build with their subagents and leave a report; every diff, fix rounds included, is reviewed by an agent that did not write it; main accepts on evidence with a gate receipt; a report is input, never a fact

This is a method the agent follows, not something the hooks enforce. The main session designs, decides and integrates; helpers build or gather facts from a spec file. The always-loaded invariants live in templates/rules/orchestration.md (a plugin cannot ship rules; setup offers to copy it).

StepWhat happensOpen
1. Spec fileGoal, non-goals, acceptance AC-n written first, value sources, gates; a depth pass, a practice line and a review line before hand-over; a reader who did not write it checks it against the codeSPEC-TEMPLATE.md · reference/spec-depth.md
2. Buildexecutor (or your own builder) in a worktree, one integrator; several sessions → one main and windows working from brief filesreference/parallel-development.md · reference/window-cycle.md · WINDOW-BRIEF-TEMPLATE.md
3. Review, fix rounds includedEvery nontrivial diff, and every fix round's diff, reviewed by an agent that did not write it; findings triaged to the owning layer; a fix round may not redesignreference/review-loop.md §0–§1 · reference/review-classes.md · reference/acceptance.md
4. Acceptance recordOne file per accepted head: spec, rounds, review, gates re-run on that tree, one ruling per findingreference/acceptance.md · ACCEPTANCE-TEMPLATE.md · reference/orchestrator-fact-check.md
5. Findings registryEach confirmed finding logged by class and family; a family seen three times is promoted into a checkreference/review-loop.md §2

Working as a team: one main session and three windows

The way the maintainer works daily: you talk to ONE session — main — and main runs three more Claude Code sessions (windows) on the same repository. Work crosses between them as files; messages only point at files.

                         you
                          │  talk only here
                   ┌──────┴──────┐
                   │    main     │  plans the round · specs · rulings · acceptance · memory
                   └──┬───┬───┬──┘
       brief file ↓   │   │   │   ↑ report file + message ≤ 5 lines
               ┌──────┘

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • plugins/memory-kit/skills/close-session/SKILL.md4.2 KBupstream ↗
    ---
    name: close-session
    description: End-of-session ritual — audit today's patterns against accumulated memory, propose promotions, refresh MEMORY.md, and write the session handoff. Use when the user says "/memory-kit:close-session", "закрой сессию", "закрываем", "we're done for today", "wrap up".
    allowed-tools: Read, Write, Edit, Grep, Glob, Bash
    ---
    
    # /close-session — the end-of-session ritual
    
    You close the session in four steps. Don't just dump — **audit**. Everything you write, you
    announce briefly; anything promoted to rules/concepts needs the user's verbal "yes" first.
    
    ## Step 1 — Capture what's new
    Scan this session for observations worth keeping. Append each to `.claude/memory/MEMORY.md`
    as a ONE-LINE `[YYYY-MM-DD]`-prefixed entry. Short, scannable, no essays (long rationale
    belongs in a concept article, step 2).
    - **File each line under a TOPIC heading** of the patterns section (engineering, process,
      infra, the domain…) — create the topic if none fits. Never open a heading named after the
      session or the date (`### s66 (2026-09-25)`, `## Session 65 wrap`): the date lives in each
      line's prefix, the session narrative lives in the handoff (step 4). The SessionStart hook
      flags such headings.
    - **Don't capture what the always-loaded layer already says** (`CLAUDE.md`, rules without
      `paths:`) or a number whose source of truth lives elsewhere (a price table, a config) —
      point at the source instead of copying the value.
    
    ## Step 2 — Audit & promote (the valuable part)
    Read the date-tagged entries in MEMORY.md. Look for repetition: **did this pattern appear on
    3+ different dates?** Surface 2-4 candidates, be specific: "noticed [date], [date], [date] you
    said X — codify as a rule or a concept article?"
    - User says yes → write `knowledge/concepts/<topic>.md` (facts + rationale; frontmatter per
      `knowledge/index.md` spec) or `.claude/rules/<name>.md` (mechanical always/never constraint;
      only for patterns stable 6+ months). Update `knowledge/index.md` (one line per concept).
    - Promoted or long-absorbed entries get PRUNED from MEMORY.md — that's how it stays under its
      caps (180 lines / 32 KB / 3000 chars per line).
    - Writing a fact into a second place? `reference/doc-governance.md` — one SSOT per fact, and when
      a fact changes you grep its restatements in the same pass. A product or architecture decision
      goes to the ledger instead — `projects/<name>/decisions-log.md`, format in
      `reference/decisions-log.md`. A plan, a spec, a research finding or a QA record is NOT memory:
      it belongs in that project's folder, per the map in its `README.md`.
    
    ## Step 3 — Refresh the MEMORY.md header
    The header (everything above the first `---`) is «current state of work», 2-3 sentences,
    **REPLACED** every close — never a chronicle of past sessions. Per-session detail lives in the
    handoff, not stacked in the header.
    
    ## Step 4 — Write the handoff
    Copy `context/handoffs/HANDOFF-TEMPLATE.md` → `context/handoffs/<topic>-<YYYY-MM-DD>.md` and
    fill its five sections (what was done · where things stand · memory updates · next steps ·
    opening note). The SessionStart hook injects the newest handoff next time — this file IS the
    "remember where we left off" mechanism.
    
    ## Also check (30 seconds)
    - **Experiment hygiene:** any `experiments/*-YYYYMMDD/` older than 30 days → ask: still active
      or close (distill → delete)?
    - **Backlogs:** `projects/*/BACKLOG.md` task statuses reflect today's reality — a `DONE`
      nobody verified is still `IN PROGRESS`.
    - **Project map:** anything you wrote today into a project folder is a row in that project's
      `README.md` map, and the map's `Last verified` is today's date.
    - **Specs vs code:** any spec still `building` after a merge, or any `assumed` spec → run
      `/memory-kit:code-sync` (it reconciles statuses from repo evidence; this ritual does not).
    - **Caps:** if MEMORY.md is near any cap, do a deeper prune now, not "next time".
    
    ## What NOT to do
    - Don't promote without the user's yes. Repetition makes a CANDIDATE, not a rule.
    - Don't stack "Prior session" paragraphs in the MEMORY header — replace it.
    - Don't group today's lines under a session heading — see Step 1.
    - Don't write a handoff longer than ~1 screen. It's a note, not a transcript.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/awrshift-agent-memory-kit-plugins-memory-kit-skills-close-session.md

// REPO STATS

34 stars
0 open issues
Last commit: 2d ago