Przejdź do treści
Biblioteka skilli
AI i agenci · Integracja z narzędziem

lorekit-memory

/lorekit-memory

Zapewnia agentom kodującym wspólną trwałą pamięć przez serwer MCP LoreKit, czytając lekcje z zakresu zadania na starcie i zapisując nowe po błędach, pętlach i pułapkach.

Repozytorium
lorekit ↗
Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zapewnia agentom kodującym wspólną trwałą pamięć przez serwer MCP LoreKit, czytając lekcje z zakresu zadania na starcie i zapisując nowe po błędach, pętlach i pułapkach.

Argumenty

/lorekit-memory [read|write] [scope-hint or lesson]
Oryginalny opis (EN)

Shared persistent memory for coding agents, backed by LoreKit's MCP server. Reads scoped lessons at the start of a task or when navigating into unfamiliar code (narrow-to-broad scope resolution across branch, repo, project, and global), and writes a lesson when something goes wrong — a stuck loop, a repeated command failure, a surprising gotcha, a near-miss, or a wrong assumption that cost time. Lessons are phrased as observations (never rigid rules), scoped to the narrowest namespace that fits, and deduplicated on write. Use at task start, before risky operations, and after any failure or ret

Jak działa

  1. When to read (intake)
  2. When to write (retrospective)
  3. Scope in one line
  4. The MCP tools
  5. Setup
Sekcje z nagłówków SKILL.md, w oryginale · 140 linii, 981 słów
Podgląd SKILL.md
---
name: lorekit-memory
description: >
  Shared persistent memory for coding agents, backed by LoreKit's MCP server.
  Reads scoped lessons at the start of a task or when navigating into
  unfamiliar code (narrow-to-broad scope resolution across branch, repo,
  project, and global), and writes a lesson when something goes wrong — a
  stuck loop, a repeated command failure, a surprising gotcha, a near-miss,
  or a wrong assumption that cost time. Lessons are phrased as observations
  (never rigid rules), scoped to the narrowest namespace that fits, and
  deduplicated on write. Use at task start, before risky operations, and
  after any failure or retrospective. Triggers on "read lessons", "check
  memory", "what do we know about", "remember this", "save a lesson",
  "record this gotcha", "capture this lesson", "/lorekit-memory".
user-invocable: true
argument-hint: '[read|write] [scope-hint or lesson]'
license: MIT
metadata:
  author: mthines
  version: '1.1.0'
  workflow_type: shared-memory-intake-and-retrospective
  tags:
    - lorekit
    - persistent-memory
    - shared-memory
    - mcp
    - lessons
    - self-improvement
    - retrospective
---

# LoreKit Memory

Give every agent a shared, persistent memory.
Lessons live in LoreKit (a Supabase-backed MCP server), so what one agent
learns on one machine — or in CI — is available to every agent, everywhere,
in the next session.

This skill has two jobs, mirroring the read-on-start / write-on-failure loop
of the `aw` autonomous-workflow agent:

1. **Read** scoped lessons at the start of a task and before risky steps.
2. **Write** a lesson when something goes wrong, so the next run avoids it.

Both jobs run through LoreKit's `memory.*` MCP tools.
If those tools are not connected, this skill is a no-op — say so once and
continue the task; never block work because memory is unavailable.

> **Wiring a loop into your own skill?** This skill does the runtime read/write.
> To set up a *self-improvement loop* for a skill, workflow, or agent — so it
> reads its own lessons on every run and promotes proven ones into permanent
> rules — use the **`lorekit-setup`** skill, the authoring counterpart to this
> one.

> **Modes.** Memory has a controllable backend (`lorekit doctor` shows the
> resolved one): `remote` (the hosted LoreKit server — the default), `local`
> (markdown files in two tiers — a per-user **home** tier at `~/.lorekit/` and
> an opt-in per-repo **project** tier at `<repo>/.lorekit/`), or `off`
> (disabled). **`local` means _not_ on the hosted website** — local lessons stay
> on disk and never sync to the LoreKit dashboard. `global` lessons go to home;
> `repo`/`branch` lessons go to the project tier once you create `<repo>/.lorekit/`
> (commit it to share with your team, or gitignore it to keep it private), else
> home. See the `@lorekit/cli` README for the control model, the two-tier merge,
> and precedence/deny rules.

---

## When to read (intake)

Read at the moments where prior lessons change what you do:

- **Task start** — before planning any non-trivial change.
- **Navigation** — the first time you open an unfamiliar package, module, or subsystem.
- **Before a risky operation** — migrations, deploys, worktree/branch surgery, force pushes, anything hard to reverse.

Follow [rules/intake.md](./rules/intake.md).
The short version: resolve the current scope, list lessons narrow-to-broad,
and treat matches as *considerations*, not commands. When a run is about to
change code, intake step 6 reads the standard shared **`codebase-knowledge`**
bucket — the cross-loop `hotspot::<path>` / `knowledge::<symbol>@<path>` record
for the files this run will touch, matched by `symbol@path`. A run that verifies
a structural fact contributes it back, so the layer compounds across every
LoreKit loop in the repo (contract in the `lorekit-setup` skill).

## When to write (retrospective)

Write when a run produces a durable observation worth carrying forward.
The trigger is friction, not success. Ask the 30-second question:

> Was there a stuck loop, a repeated failure, a surprise, a near-miss, or a
> guess that paid off — something a future run would benefit from knowing?

If yes, write it. If the answer is genuinely nothing, write nothing —
empty retrospectives are skipped entirely.

Follow [rules/retrospective.md](./rules/retrospective.md).
The short version: phrase the lesson as an observation, pick the narrowest
scope that fits, check for a near-duplicate first, then `memory.write`.

---

## Scope in one line

Lessons are partitioned by a canonical scope string (`::` is the only separator):

```text
global                                universal principles
project::{name}                       monorepo-wide
repo::{owner}/{repo}                   this repository's codebase
branch::{owner}/{repo}::{branch}       short-lived, this branch only
```

Read narrow-to-broad and merge; write to the narrowest scope that correctly
describes where the lesson applies.
Full resolution rules: [references/scope-resolution.md](./references/scope-resolution.md).

---

## The MCP tools

| Tool | Use | Token |
|------|-----|-------|
| `memory.list` | List lessons for one scope (newest first, tag filter). `scope` is optional — omit it to list across every scope you can see | read |
| `memory.search` | Full-text search across scopes (supports `repo::owner/*`) | read |
| `memory.read` | Read one lesson by key (`scope` optional — see below) — or several at once via `refs: ["scope::key", …]` (one round trip, up to 32) | read |
| `memory.write` | Store or update a lesson (same scope+key updates in place) | read+write |

Write tools need write permission (`lk_rw_*` or `lk_wo_*`); read tools need read
permission (`lk_rw_*` or `lk_ro_*`). A read-only token cannot write and a
write-only token cannot read — if a call fails with an authorization error,
report it and move on; do not retry.

Holding only a bare key, with no scope? Call `memory.read { key }` without a
`scope`. It resolves across every scope you can see, preferring the most
specific — `project`, then `branch`, then `repo`, then `global` — and the
response's `scope` field names the one that answered. If the key also exists
elsewhere, `other_scopes` lists those: that is your cue to pass an explicit
`scope` next time, because only you know which one you meant. An omitted scope
does NOT mean `global`. The same applies to `memory.list` and
`memory.list_archived`, which simply list across everything instead of
resolving to one winner.

Already know the exact `scope::key` refs you need — from a prior `memory.list`
or `memory.search`, or from citations another lesson names — and need more than
one? Pass them all as `memory.read`'s `refs` array instead of one call per
lesson. Each ref resolves independently: an unresolved one lands in the
response's `missing` list rather than failing the whole call, and matching is
against the **verbatim stored scope** (no case-folding), unlike a single
`scope`/`key` read.

Every lesson this skill writes carries the tag `skill::lorekit-memory` plus a
`source::<trigger>` tag (for example `source::stuck-loop`) so lessons are
easy to find and audit later.

---

## Setup

Install the skill and configure the MCP endpoint with the LoreKit CLI:

```bash
npx @lorekit/cli install
npx @lorekit/cli doctor
```

`install` scaffolds this skill into `.claude/skills/` and adds the LoreKit
server to `.mcp.json`.
`doctor` verifies connectivity, token permission, and scope detection.
See the CLI's own README for flags and troubleshooting.
Pliki w paczce (4)
  • SKILL.md 7 KB
  • references/scope-resolution.md 4 KB
  • rules/intake.md 4 KB
  • rules/retrospective.md 4 KB

Wersje

W bazie nie ma innych skilli o nazwie lorekit-memory.

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki afde5700f51a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100lorekit-groom
    Porządkuje zgromadzoną pamięć LoreKit: scala zbliżone lekcje, usuwa słabe, ustawia wygasanie i archiwizuje przestarzałe, zawsze najpierw analizując bez zmian i proponując plan do zatwierdzenia.
  • 87lorekit-setup
    Prowadzi przez sześć etapów, by skill, przepływ lub zadanie CI poprawiały się z każdym uruchomieniem i potrafiły to udowodnić.
  • 100agent-kernel
    Zapewnia Claude Code wspólne trwałe reguły, zatwierdzane propozycje pamięci, Failure Lessons, ograniczony lokalny kontekst, sesje, strażnika architektury, hooki Claude i lokalny MCP.
  • 90lessons
    Przypomina lekcje z poprzednich błędów przed edycją pliku, zmianą stanu i po każdej korekcie lub nieoczekiwanym wyniku.
  • 90lessons
    Przypomina zapisane lekcje przed każdą zmianą pliku lub stanu i po błędzie, korekcie albo zaskakującym wyniku.
  • 100agent-kernel
    Zapewnia agentowi kodującemu zgodnemu z AGENTS.md wspólne trwałe reguły, zatwierdzane propozycje pamięci, Failure Lessons, lokalne sesje, strażnika architektury, hooki i lokalny MCP.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.