session-wrap

ai-native-camp/camp-2

Analyze completed work and wrap up coding sessions with multi-agent insights.

What is session-wrap?

Session Wrap guides you through a structured end-of-session workflow using parallel analysis agents. It examines git changes, extracts learnings, identifies automation opportunities, suggests documentation updates, and proposes follow-up tasks—then lets you commit, document, or create automation based on the analysis.

Checks git status and summarizes files changed in the session
Runs 4 parallel analysis agents (doc-updater, automation-scout, learning-extractor, followup-suggester) to examine completed work
Validates Phase 1 proposals with a duplicate-checker agent to avoid redundant suggestions
Presents integrated results with documentation updates, automation ideas, learning points, and next-session priorities
Offers interactive action selection to commit changes, update documentation, or create new automation
Supports direct commit via message argument for non-interactive workflows

How to install session-wrap

npx skills add https://github.com/ai-native-camp/camp-2 --skill session-wrap

Claude Code

Cursor

Windsurf

Cline

How to use session-wrap

1.Run the skill when you're ready to wrap up a session (e.g., via `/wrap` or 'wrap up session' prompt)
2.Review the parallel analysis results: documentation suggestions, automation opportunities, learning points, and follow-up tasks
3.Check the duplicate-checker validation to see which proposals are new vs. redundant
4.Select which actions to perform: commit changes, update CLAUDE.md, create automation, or skip
5.Execute your selected actions and end the session with a clear record of progress

Use cases

Good for

End a significant coding session and document what was learned and accomplished
Identify repetitive patterns in your work that could be automated or turned into reusable skills
Prepare handoff notes before switching to a different project or team member
Review git changes and decide which modifications warrant commit messages and documentation updates
Extract key decisions and discoveries to update your CLAUDE.md or context files

Who it's for

Developers ending work sessions who want structured reflection and documentation
Teams using multi-agent workflows to capture institutional knowledge
Anyone using Claude Code or Cursor who wants to systematize session closure and learning capture

session-wrap FAQ

What if I have no git changes?

The skill checks git status first; if there are no changes, it will note that and you can still review learnings or skip the wrap entirely.

Can I use this without interactive prompts?

Yes—pass a commit message as an argument to commit directly without the interactive action-selection menu.

What's the difference between the doc-updater and learning-extractor?

doc-updater checks if CLAUDE.md or context.md need updates based on session work; learning-extractor extracts TIL (Today I Learned) points and mistakes for your own knowledge capture.

How does the duplicate-checker prevent redundant suggestions?

It validates Phase 1 proposals against existing documentation and automation to flag complete duplicates (skip), partial overlaps (merge), or new ideas (approve).

When should I skip using this skill?

Skip for very short sessions with trivial changes, code exploration without modifications, or quick one-off questions that don't warrant session analysis.

Full instructions (SKILL.md)

Source of truth, from ai-native-camp/camp-2.

name: session-wrap description: This skill should be used when the user asks to "wrap up session", "end session", "session wrap", "/wrap", "document learnings", "what should I commit", or wants to analyze completed work before ending a coding session. version: 2.0.0

Session Wrap Skill

Comprehensive session wrap-up workflow with multi-agent analysis.

Execution Flow

┌─────────────────────────────────────────────────────┐
│  1. Check Git Status                                │
├─────────────────────────────────────────────────────┤
│  2. Phase 1: 4 Analysis Agents (Parallel)           │
│     ┌─────────────────┬─────────────────┐           │
│     │  doc-updater    │  automation-    │           │
│     │  (docs update)  │  scout          │           │
│     ├─────────────────┼─────────────────┤           │
│     │  learning-      │  followup-      │           │
│     │  extractor      │  suggester      │           │
│     └─────────────────┴─────────────────┘           │
├─────────────────────────────────────────────────────┤
│  3. Phase 2: Validation Agent (Sequential)          │
│     ┌───────────────────────────────────┐           │
│     │       duplicate-checker           │           │
│     │  (Validate Phase 1 proposals)     │           │
│     └───────────────────────────────────┘           │
├─────────────────────────────────────────────────────┤
│  4. Integrate Results & AskUserQuestion             │
├─────────────────────────────────────────────────────┤
│  5. Execute Selected Actions                        │
└─────────────────────────────────────────────────────┘

Step 1: Check Git Status

git status --short
git diff --stat HEAD~3 2>/dev/null || git diff --stat

Step 2: Phase 1 - Analysis Agents (Parallel)

Execute 4 agents in parallel (single message with 4 Task calls).

Session Summary (Provide to all agents)

Session Summary:
- Work: [Main tasks performed in session]
- Files: [Created/modified files]
- Decisions: [Key decisions made]

Parallel Execution

Task(
    subagent_type="doc-updater",
    description="Document update analysis",
    prompt="[Session Summary]\n\nAnalyze if CLAUDE.md, context.md need updates."
)

Task(
    subagent_type="automation-scout",
    description="Automation pattern analysis",
    prompt="[Session Summary]\n\nAnalyze repetitive patterns or automation opportunities."
)

Task(
    subagent_type="learning-extractor",
    description="Learning points extraction",
    prompt="[Session Summary]\n\nExtract learnings, mistakes, and new discoveries."
)

Task(
    subagent_type="followup-suggester",
    description="Follow-up task suggestions",
    prompt="[Session Summary]\n\nSuggest incomplete tasks and next session priorities."
)

Agent Roles

Agent	Role	Output
doc-updater	Analyze CLAUDE.md/context.md updates	Specific content to add
automation-scout	Detect automation patterns	skill/command/agent suggestions
learning-extractor	Extract learning points	TIL format summary
followup-suggester	Suggest follow-up tasks	Prioritized task list

Step 3: Phase 2 - Validation Agent (Sequential)

Run after Phase 1 completes (dependency on Phase 1 results).

Task(
    subagent_type="duplicate-checker",
    description="Phase 1 proposal validation",
    prompt="""
Validate Phase 1 analysis results.

## doc-updater proposals:
[doc-updater results]

## automation-scout proposals:
[automation-scout results]

Check if proposals duplicate existing docs/automation:
1. Complete duplicate: Recommend skip
2. Partial duplicate: Suggest merge approach
3. No duplicate: Approve for addition
"""
)

Step 4: Integrate Results

## Wrap Analysis Results

### Documentation Updates
[doc-updater summary]
- Duplicate check: [duplicate-checker feedback]

### Automation Suggestions
[automation-scout summary]
- Duplicate check: [duplicate-checker feedback]

### Learning Points
[learning-extractor summary]

### Follow-up Tasks
[followup-suggester summary]

Step 5: Action Selection

AskUserQuestion(
    questions=[{
        "question": "Which actions would you like to perform?",
        "header": "Wrap Options",
        "multiSelect": true,
        "options": [
            {"label": "Create commit (Recommended)", "description": "Commit changes"},
            {"label": "Update CLAUDE.md", "description": "Document new knowledge/workflows"},
            {"label": "Create automation", "description": "Generate skill/command/agent"},
            {"label": "Skip", "description": "End without action"}
        ]
    }]
)