메뉴
Save information to Memex long-term memory. Routes how-tos/worked-episodes to a case, preferences/conventions to KV, or facts/decisions to a note.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
SOC 직업 분류 기준
Deliberately capture what you JUST did as a Memex case — a worked episode (trigger / situation / actions / outcome / lesson) the system derives a reusable procedure from. Use right after finishing a multi-step task, diagnosing a bug, or resolving an incident, or when asked to 'record/log/save how I did this'. Distinct from /remember (auto-routes by shape) and /extract-case (converts existing content) — this is the structured, in-the-moment path.
Resume work from previous /handoff notes. Presents a multi-select list of the most recent handoff summaries, lets the user pick any number of relevant items (or 'load more'), then loads every selected note, summarizes them jointly, and asks what the next steps should be. Use at the start of a fresh session, or when the user says 'pick up where we left off', 'continue', 'what was I working on', 'resume', or 'catch me up on this'.
Tell Memex a surfaced memory was wrong, outdated, or noise. Use whenever you say 'stop suggesting that', 'that's stale / outdated / wrong', 'we removed that', or want a misleading fact to stop surfacing — records a not_helpful outcome on the offending unit(s) and deprioritizes them (the negative-signal loop). NOT for confirming a fix worked (that's a helpful outcome).
Turn a note, a markdown file, or a URL into a Memex case — but only when the content actually contains a reusable how-to / worked episode. Gated: if there's no case in it, files nothing.
Write a technical handoff summary of the current work to Memex — a descriptive, summarizing writeup of what you've been doing, the approach and key decisions, where it stands, and what's next — so you (or another agent) can pick the thread back up later. Use at the end of a workday, when wrapping up an involved conversation, or whenever the user says 'hand this off', 'write up where we are', 'summarize this so I can continue later', or 'I'll come back to this'.
Distill the durable learnings from the current session and save them to Memex, routing each into the right memory layer by shape. Use when the user says 'capture what I learned', 'save the lessons from this session', 'what should we remember from this', or wants the takeaways from the whole conversation kept — as opposed to one named episode (`/case`) or one supplied fact (`/remember`).
| name | remember |
| description | Save information to Memex long-term memory. Routes how-tos/worked-episodes to a case, preferences/conventions to KV, or facts/decisions to a note. |
| argument-hint | [what to remember] |
Content: use $ARGUMENTS if provided; otherwise infer the most important persistable context.
Route by shape, NOT by trigger word — this is the most important step. Pick the storage layer first:
memex_kv_put with the scope-qualifier-derived namespace (user:, project:<id>:, app:<app-id>:, global:) and an ordinary <scope>:<field> key. See KV-namespace rules in the system prompt. Do NOT save these as notes.memex_case_submit — composes the episode template (trigger / situation / actions / outcome / lesson) and files it as a case NOTE in a hidden system vault. The system DERIVES the procedure (and any higher-order strategy) from the cases you submit — you never author a procedure or strategy directly. Pass case_of=<procedure-id> when you already have a procedure for this how-to (probe with memex_procedural_get_by_identity — see "Procedural memory" below).memex_add_note (or memex_append_note to extend an existing note). Use the note-format guidance below.Note format (only when step 2 picked memex_add_note):
"claude-code""manual-capture" + 1-3 topic tags (the plugin auto-injects ambient tags — do not repeat them)Template (note path only, for structured content — a decision, brief, RFC, reflection): suggest or select a template before writing. Skip for short/quick captures.
memex_list_templates — it returns a markdown string (parse the - **slug** [source] — name: description bullets), not JSON.architectural_decision_record), auto-select it; otherwise present a short AskUserQuestion pick-list of the top candidates plus a "plain note" option.memex_get_template(type=<slug>) — note the param is named type, not slug, despite the tool's own hint.template=<slug> is provenance/filter metadata only — it does NOT auto-structure the note, so write the body to match the scaffold yourself, then memex_add_note(..., template=<slug>).Save: call the tool picked in step 2. For memex_add_note the plugin auto-defaults background: true; pass it explicitly only if you need synchronous ingestion.
A PreToolUse hook adds ambient tags (surface / session / project, git branch+sha+repo+dirty, model, plugin version) to every memex_add_note and memex_case_submit call, and on notes defaults background=true and vault_id=<active_vault> when absent — so don't set these yourself. Your explicit tags are merged (deduplicated, never stripped) and an explicit background: false is preserved.
memex_memory_deprioritize(unit_id, reason) — non-destructive. Lowers retrieval rank; reversible via memex_memory_restore.Follow the 5-step resolution flow in the system prompt (§"5-step resolution flow", arriving via the SessionStart hook). The paired-write shape on failure is:
memex_record_outcome(units=[{unit_id, verb: "not_helpful", reason}]) AND memex_memory_deprioritize(unit_id, reason)
Bare success=true/success=false without units returns HTTP 400.
"How to do X" knowledge lives on the procedural plane — distinct from notes (long-form prose) and KV (preferences / bindings). The agent never authors a procedure or strategy directly: you file worked episodes via memex_case_submit, and the system DERIVES the procedure (and any higher-order strategy) from those cases. Procedures carry an identity anchor (kind, scope, verb, context), and arrive as pinned cards in your SessionStart briefing.
Tools (exposed automatically by the plugin's .mcp.json):
| Tool | When |
|---|---|
memex_case_submit | File a worked episode as a case NOTE (hidden system vault). Required: title, trigger, outcome, scope (global/project:<id>/app:<id>), scope_reasoning (one line) — the call 422s without scope/scope_reasoning. Pass case_of=<procedure-id> when known; contested assignments land in the lint queue (assignment.mode="escalated"). This is the agent's ONLY procedural write. |
memex_procedural_get_by_identity | Probe by (kind, scope, verb, context). Returns null on miss — the cheap "do we already have a procedure for this?" check. If it returns an entry, pass its id as case_of when you submit the case. |
memex_procedural_get | Fetch a single derived procedure by UUID. |
memex_procedural_search | Hybrid BM25 + vector search (RRF-merged) over derived procedures. Required: query. |
Scope grammar (anchors + pin-chain context):
global — cross-project convention.project:<id> — one project.app:<id> — one application (e.g. app:claude-code).user scope — per-user briefing curation is done by pinning (an operator surface), not by scoping entries.The probe-then-file pattern (the load-bearing operational pattern):
# 1. probe for an existing derived procedure on the anchor
existing = memex_procedural_get_by_identity(kind="procedure", scope="global", verb="rotate", context="creds")
# 2. file the worked episode; link it to the procedure if one already exists
case_of = existing["id"] if existing is not None else None
memex_case_submit(title="Rotated project API creds", trigger="rotating the project API credentials",
outcome="...", scope="global", scope_reasoning="creds rotation is a cross-project routine",
case_of=case_of)
# scope + scope_reasoning are REQUIRED (422 without them).
# the system derives/updates the procedure from this case — you do not write one.
Briefing: pinned procedure cards arrive automatically inside the SessionStart briefing (the plugin passes --app claude-code so the app:claude-code pin context is included). There is no briefing tool to call.
When to choose case vs. KV vs. note:
memex_case_submit) — "what just happened, and next time I'd want these steps back": a how-to / worked episode. The system derives the procedure.<scope>:<field>) — a preference / convention / binding.memex_memory_summarize_node(entity_id, scope) — synchronous reflection. 'incremental' (default) or 'full' (capped 100 units). Rate-limited: 1 call per (entity, vault) per 60s.memex_memory_reconsolidate(entity_id, vault_id) — entity-scoped contradiction detection + reflection.memex_memory_consolidate(vault_id, dry_run) — vault-scoped batch deprioritization. Use sparingly.