跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

context-saver

Write the current session's in-flight work state to a human-readable handoff doc on disk (docs/context/CONTEXT-{topic}.md) so a future chat session — or another person — can pick up exactly where this one stops. Distinct from Claude Code's built-in memory system, which captures long-lived facts and preferences; this skill captures **active session context** (what's being built right now, which files are mid-edit, what's been tried, what's next). Use when the user says "save context", "checkpoint", "save progress", "preserve state", "save before I step away", "dump this so I can continue tomorrow", or before ending a long session with incomplete work. Optimizes for correctness, completeness, minimal size, and trajectory preservation.

mhylle · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add mhylle/claude-skills-collection --skill context-saver

技能说明


name: context-saver description: Write the current session's in-flight work state to a human-readable handoff doc on disk (docs/context/CONTEXT-{topic}.md) so a future chat session — or another person — can pick up exactly where this one stops. Distinct from Claude Code's built-in memory system, which captures long-lived facts and preferences; this skill captures active session context (what's being built right now, which files are mid-edit, what's been tried, what's next). Use when the user says "save context", "checkpoint", "save progress", "preserve state", "save before I step away", "dump this so I can continue tomorrow", or before ending a long session with incomplete work. Optimizes for correctness, completeness, minimal size, and trajectory preservation. disable-model-invocation: true argument-hint: "[topic?]"

Context Saver

Contents

Reference files (open one when a step points to it):

  • references/context-template.md: Context File Template

Preserve in-flight session state to disk for seamless continuation in another session. Extracts signal from noise — captures the essential state (trajectory, decisions, active files, blockers, next steps) while discarding ephemeral details (exploratory reads, rejected paths, verbose tool output).

Scope — how this differs from auto-memory

Claude Code has a built-in memory system at ~/.claude/projects/.../memory/ that captures long-lived, typed entries (user, feedback, project, reference). That handles persistent knowledge: facts about you, validated preferences, project-state that's true across sessions.

This skill handles what memory doesn't: the snapshot of what you're actively doing right now. It's the answer to "I need to step away mid-task — capture where I am so a new session can pick up seamlessly."

  • Memory: "This user prefers pytest over unittest." (always true, loads into every session)
  • This skill: "Currently refactoring src/auth/token.service.ts:45-78 — tried approach A (failed, see line 60), now trying approach B, next step is to update the test at __tests__/token.service.spec.ts:120." (true right now, for this specific task)

Memory grows bigger over months; context-save docs are ephemeral — delete them once the work they describe lands.

When to Use

  • User explicitly requests context saving ("save context", "checkpoint this")
  • Before ending a long session with incomplete work
  • When switching focus and needing to preserve state
  • Before attempting risky operations that may require rollback
  • When collaborating and need to hand off context to another session

Core Principles

Signal Extraction Priority

  1. Trajectory (highest): What is the user trying to achieve? What's the end goal?
  2. Decisions: What choices were made and why? What was rejected?
  3. State: What code is being modified? What's the current progress?
  4. Approaches: What has been tried? What worked/failed?
  5. Noise (discard): Exploratory reads, rejected paths, verbose tool output

Information Density Rules

  • Include: Specific file:line references, concrete decisions, blockers, next steps
  • Exclude: General exploration, routine file reads, verbose error traces
  • Compress: Long code blocks → key excerpts with line references
  • Preserve: User-stated requirements verbatim, even if seemingly minor

Context File Structure

Create context files in docs/context/ or project root as CONTEXT-{topic}.md:

# Context: {Descriptive Title}

> Saved: {ISO timestamp}
> Session: {Brief session identifier}
> Status: {in-progress | blocked | ready-for-review | completed}

## Trajectory

**Goal**: {One sentence: what is the user ultimately trying to achieve?}

**Success Criteria**:
- {Concrete, measurable outcome 1}
- {Concrete, measurable outcome 2}

**Current Phase**: {Where in the journey: planning | implementing | debugging | testing | refining}

## Problem Statement

{2-4 sentences describing the core problem. Include:}
- What triggered this work
- Key constraints or requirements
- Why existing solutions don't suffice

## Active Code Focus

### Primary Files

| File | Lines | Reason |
|------|-------|--------|
| `path/to/file.ts` | 45-78 | {Why this section matters} |
| `path/to/other.ts` | 12-34 | {What's being modified here} |

### Key Code Context

```{language}
// {file}:{start_line}-{end_line}
// {Brief explanation of what this code does and why it's relevant}
{Essential code excerpt - max 30 lines}

Dependencies & Relationships

  • {file1} imports from {file2} via {what}
  • {component} depends on {service} for {why}

Decisions Made

DecisionRationaleAlternatives Rejected
{Choice made}{Why this approach}{What was considered but rejected}

Approaches Taken

Succeeded

  • {Approach}: {Brief result}

Failed/Abandoned

  • {Approach}: {Why it didn't work, lesson learned}

In Progress

  • {Current approach}: {Current state, what remains}

User Requirements

{Verbatim or near-verbatim capture of specific user requests}

  • "{
阅读完整来源 ↗