home / skills / catlog22 / claude-code-workflow / memory-capture

memory-capture skill

/.claude/skills/memory-capture

This skill captures memory with compact session or quick tips, routing input to structured exports or rapid notes.

npx playbooks add skill catlog22/claude-code-workflow --skill memory-capture

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
5.0 KB
---
name: memory-capture
description: Unified memory capture with routing - session compact or quick tips. Triggers on "memory capture", "compact session", "save session", "quick tip", "memory tips", "记录", "压缩会话".
allowed-tools: mcp__ccw-tools__core_memory(*), Read(*), AskUserQuestion
---

# Memory Capture Skill

Unified memory capture skill that routes to two execution modes:
- **Compact**: Compress full session memory into structured text for recovery
- **Tips**: Quick note-taking for ideas, snippets, and insights

## Architecture Overview

```
┌─────────────────────────────────────────────────────┐
│  Memory Capture (Router)                            │
│  → Parse input → Detect mode → Route to phase       │
└───────────────┬─────────────────────────────────────┘
                │
        ┌───────┴───────┐
        ↓               ↓
  ┌───────────┐   ┌───────────┐
  │  Compact  │   │   Tips    │
  │  (Phase1) │   │  (Phase2) │
  │  Full     │   │  Quick    │
  │  Session  │   │  Note     │
  └─────┬─────┘   └─────┬─────┘
        │               │
        └───────┬───────┘
                ↓
        ┌───────────────┐
        │  core_memory  │
        │   (import)    │
        └───────────────┘
```

## Execution Flow

### Step 1: Parse Input & Route

Detect execution mode from user input:

**Auto-Route Rules** (priority order):

| Signal | Route | Examples |
|--------|-------|---------|
| Keyword: compact, session, 压缩, recovery, 保存会话 | → Compact | "compact current session" |
| Keyword: tip, note, 记录, 快速 | → Tips | "记录一个想法" |
| Has `--tag` or `--context` flags | → Tips | `"note content" --tag bug` |
| Short text (<100 chars) + no session keywords | → Tips | "Remember to use Redis" |
| Ambiguous or no arguments | → **AskUserQuestion** | `/memory-capture` |

**When ambiguous**, use AskUserQuestion:

```
Question: "选择记忆捕获模式"
Options:
  1. Compact - 压缩当前完整会话记忆(用于会话恢复)
  2. Tips - 快速记录一条笔记/想法/提示
```

### Step 2: Execute Selected Phase

Based on routing result, read and execute the corresponding phase:

- **Compact mode** → Ref: [phases/01-compact.md](phases/01-compact.md)
- **Tips mode** → Ref: [phases/02-tips.md](phases/02-tips.md)

**Phase Reference Documents** (read on-demand when phase executes):

| Mode | Document | Purpose |
|------|----------|---------|
| Compact | [phases/01-compact.md](phases/01-compact.md) | Full session memory compression and structured export |
| Tips | [phases/02-tips.md](phases/02-tips.md) | Quick note-taking with tags and context |

### Step 3: Save via core_memory

Both phases converge on the same storage mechanism:

```javascript
mcp__ccw-tools__core_memory({
  operation: "import",
  text: structuredText  // Generated by the selected phase
})
```

## Core Rules

1. **Single Phase Execution**: Only ONE phase executes per invocation - never both
2. **Content Faithful**: Phase files contain full execution detail - follow them verbatim
3. **Absolute Paths**: All file paths in output must be absolute
4. **No Summarization**: Compact mode preserves complete plan verbatim - never abbreviate
5. **Speed Priority**: Tips mode should be fast - minimal analysis overhead

## Input Processing

### Compact Mode Input
- Optional: `"session description"` as supplementary context
- Example: `/memory-capture compact` or `/memory-capture "completed auth module"`

### Tips Mode Input
- Required: `<note content>` - the tip/note text
- Optional: `--tag <tag1,tag2>` for categorization
- Optional: `--context <context>` for related code/feature reference
- Example: `/memory-capture tip "Use Redis for rate limiting" --tag config`

## Data Flow

```
User Input
    │
    ├─ [compact detected] → Read phases/01-compact.md
    │                        → Analyze session → Generate structured text
    │                        → core_memory import → Report Recovery ID
    │
    └─ [tips detected] → Read phases/02-tips.md
                         → Parse args → Gather context → Generate tip text
                         → core_memory import → Confirm with ID + tags
```

## Error Handling

| Error | Action |
|-------|--------|
| core_memory import fails | Retry once, then report error with structured text for manual save |
| No session context (compact) | Warn user, generate with available info |
| Empty note content (tips) | Ask user to provide content via AskUserQuestion |
| Ambiguous routing | Default to AskUserQuestion - never guess |

Overview

This skill provides unified memory capture with intelligent routing between two modes: Compact for full-session preservation and Tips for quick note-taking. It detects user intent from keywords, flags, or input length and routes the request to the appropriate phase, then saves structured output to the shared memory store. The design prioritizes fidelity in Compact mode and speed in Tips mode.

How this skill works

The router parses input and applies auto-route rules (keywords, flags, length heuristics) to select either Compact or Tips. Compact produces a verbatim, structured export of the current session for recovery; Tips creates a short, tagged note with optional contextual metadata. Both modes persist their generated structured text via a core memory import API and return a confirmation ID or error guidance.

When to use it

  • You want a complete, recoverable snapshot of an active session (Compact).
  • You need a fast note, idea, or snippet saved with tags (Tips).
  • You have short text or flags like --tag or --context that indicate a quick memo.
  • You need to preserve session state for later recovery or handoff.
  • Input is ambiguous—use the interactive prompt to choose the correct mode.

Best practices

  • Use Compact only when you want the full session recorded verbatim for future restoration.
  • Prefer Tips for short notes under ~100 characters or when using --tag/--context flags.
  • Provide explicit tags and context with tips to improve searchability and reuse.
  • If routing is ambiguous, follow the skill's ask prompt rather than forcing a mode.
  • Rely on the returned confirmation ID for retrieval and cross-referencing.

Example use cases

  • Compact the current engineering discussion before ending a long design session for later recovery.
  • Quickly save a config suggestion: `/memory-capture tip "Use Redis for rate limiting" --tag config`.
  • Capture an important multi-step debugging plan verbatim so another agent can resume it.
  • Record a short insight or reminder while coding, with context pointing to the related feature.
  • When uncertain, invoke the skill without args to receive a mode-selection prompt.

FAQ

What happens if the memory import fails?

The skill retries once; if that fails it returns the generated structured text and an error message so you can save it manually.

How does the router decide between Compact and Tips?

It uses keyword matches, flags (--tag/--context), input length heuristics, and an interactive prompt for ambiguous cases.