remember
Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope culture-nodes --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to memory", "index these", "eidetic remember", or when something learned this session should outlive it. Pairs with the sibling /recall skill.
- License 许可
- Apache-2.0
- 最近更新
- 2026-09-29
- Stars
- ★ 3
- Forks
- 0
01 前言 Front Matter
- name
- remember
- type
- command
- description
- Ingest records into the shared eidetic memory store so they can be recalled later. Drives `eidetic remember`: accepts one record as a JSON object, or a batch as NDJSON on stdin for bulk ingest. Upsert is idempotent by id (and dedups by content hash) — re-remembering updates in place, never duplicates. Stamps a `created` date on every record at ingest time. Accepts `supersedes` (id of the record this one replaces, for within-scope shadowing via `sweep`) and `links` (list of related-memory ids). The store lives at ~/.eidetic/memory (a home-dir path outside any git worktree), and the wrapper defaults records to this agent's PERSONAL, PRIVATE scope (`--scope culture-nodes --visibility private`, suffix read from culture.yaml) so they don't leak to a default/other-scope recall — Claude and the colleague backend still share them because both resolve the same suffix via this skill. Pass `--visibility public` to contribute to the shared public pool instead. Use when the user says "remember this", "store this", "save to memory", "index these", "eidetic remember", or when something learned this session should outlive it. Pairs with the sibling /recall skill.
02 资源文件 1
- 脚本scripts/remember.sh7.1 KB
03 SKILL.md 正文
remember — write to the shared eidetic memory
remember drives eidetic remember, the write half of the memory surface
(the read half is the sibling /recall skill). Records you store here are
recallable later by any agent on this machine — Claude or the colleague
backend — because the default store is one shared ~/.eidetic/memory path.
How to run
# One record (JSON object as the argument):
bash .claude/skills/remember/scripts/remember.sh \
'{"id":"d1","text":"Orin Nano draws 7-15W","type":"docs","metadata":{"source":"docs","permalink":"https://..."}}' --json
# Batch (NDJSON on stdin, one record per line) — for bulk re-index:
cat records.ndjson | bash .claude/skills/remember/scripts/remember.sh --json
# Record that supersedes an older one (same scope required for sweep to shadow):
bash .claude/skills/remember/scripts/remember.sh \
'{"id":"r2","text":"Updated Orin Nano draw: 10-20W","type":"note","supersedes":"r1","links":["r3"]}' --json
The wrapper resolves the CLI portably (installed eidetic on PATH, else
uv run eidetic from the checkout) and forwards every flag verbatim.
Record shape
| Field | Required? | Notes |
|---|---|---|
id |
yes | stable identity; the upsert key |
text |
yes | the chunk being remembered |
type |
yes | e.g. note, docs, discord, a research object type |
hash |
optional | content hash for dedup; derived from text when omitted |
metadata |
recommended | provenance + facets; round-trips verbatim on recall |
created |
auto-stamped | ISO-8601 UTC date; stamped at ingest if absent; drives freshness signal age-decay |
supersedes |
optional | id of an earlier same-scope record this one replaces; sweep auto-shadows the target |
links |
optional | list of related-memory ids; persisted for future corroboration scoring |
score and signal are recall-only and are ignored on ingest. Mind the
scope: the default personal scope is private (--scope culture-nodes --visibility private), so personal/role-gated notes stay isolated to this
agent's recall and are safe to store. Only when you deliberately write to a
public scope (--visibility public) does the record enter the shared pool
visible to every scope — keep public-scope records to public data only.
Idempotency
Re-submitting a record with the same id overwrites the previous value; a record
with a matching content hash is de-duplicated. So re-running an ingest (e.g. a
periodic re-scan) is safe and will not create duplicates.
Lifecycle — supersedes and sweep
Setting supersedes on a record declares that this record replaces an earlier one
within the same scope. The actual lifecycle transition (marking the older record
as shadowed) is applied by eidetic sweep, not by remember itself. Cross-scope
supersedes links are recorded but never auto-shadow (preserving the
public/private no-leak invariant).
To apply pending transitions after ingesting superseding records:
eidetic sweep --dry-run # preview what would change
eidetic sweep # apply transitions
Flags (forwarded to eidetic remember)
--json— structured result ({"upserted": N, "ids": [...]}) to stdout.--scope NAME/--visibility public|private— record scope. The wrapper defaults this to the agent's PERSONAL, PRIVATE scope —--scope <suffix> --visibility private, where<suffix>is read from the nearestculture.yaml(here,culture-nodes). Private records are served only to a recall in the same scope, so they don't leak to adefault/other-scope query. Pass--scopeto steer to a different scope (which then uses the plain CLI default visibility), or--visibility publicto keep the personal scope but make it shared. A wheel install with noculture.yamlfalls back to the CLI defaultdefault/public.--backend files|mongo|neo4j— defaultfiles(the shared home-dir store); usemongo/neo4j(withEIDETIC_MONGO_URI/NEO4J_URI) for a server store.
Notes
- The embed endpoint defaults to the local model-gear embed gear
(
http://localhost:8002/v1); override withEIDETIC_EMBED_URL/EIDETIC_EMBED_MODEL. Ingest still works offline (embeddings are recomputed at recall time). - Use the wrapper, not a bare
eidetic. The console script may not be onPATH(in a dev checkout it isn't); the wrapper resolves it (PATHfirst, elseuv run eidetic). For the docs, runeidetic explain rememberif installed, otherwiseuv run --project <eidetic-cli checkout> eidetic explain remember.
Provenance
First-party to eidetic-cli — eidetic owns its memory surface. Cite, don't
import: downstream repos copy this skill, they don't symlink it. See
docs/skill-sources.md.
04 同仓库更多 Skills
sample
Fixture skill proving the .qwen/skills leg carries at least one skill.
sample
Fixture skill proving the .qwen/skills leg carries at least one skill.
sample
Fixture skill proving the .qwen/skills leg carries at least one skill.
think
Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the `devague` CLI). Start from the announcement ("pretend it shipped"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame *converges*. Use when the user says "think this through", "spec this", "work backwards", "turn this idea into a spec", "announcement frame", or "devague", or when a feature request is too vague to build yet. Explore scope first when the idea touches an existing codebase — the sibling `scope` skill is the optional opening leg ahead of `think`. Once a spec exports, hand off to the sibling `spec-to-plan` skill to turn it into a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.
summarize-delivery
Close the loop after an `assign-to-workforce` run by turning what actually happened into an accountability artifact — planned versus actual delivery, mid-work decisions, plan drift, evidence-backed delivery claims, and remaining work. The plan the user confirmed is the contract; this skill records where execution obeyed it, where it changed, and what is genuinely safe to claim as delivered. Runs on complete, partial, AND failed runs — failure is reported faithfully, never smoothed over. Use when the user says "summarize delivery", "delivery summary", "wrap up", "close the loop", "what did we actually ship", or "plan versus actual", or after `assign-to-workforce` merges (or fails to merge) a plan's waves. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.
spec-to-plan
Turn a converged devague spec into a buildable plan by working forwards (the spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a converged frame, add tasks that collectively cover every coverage target (the frame's confirmed claims + honesty conditions), give each task acceptance criteria and an honest dependency order, park genuine unknowns as first-class risks, and export a plan only once it *converges*. Use when the user says "spec to plan", "stp", "turn this spec into a plan", "plan this spec", "make a build plan", or after the `think` skill exports a spec. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.