long-agent

Initialize Session

```bash

# Create session file

SESSION_ID=$(date +%Y%m%d-%H%M%S)

SESSION_FILE=~/.claude/sessions/$SESSION_ID.md

mkdir -p ~/.claude/sessions

cat > $SESSION_FILE << EOF

# Session: $SESSION_ID

Started: $(date)

Task: [Describe task]

• [ ] Step 1
• [ ] Step 2
• [ ] Step 3

[Important context to remember]

[Running notes]

EOF

echo "Session: $SESSION_FILE"

```

Track Progress

```bash

# Update progress

echo "- [x] Completed: [description]" >> $SESSION_FILE

# Add note

echo "### $(date +%H:%M) - [title]" >> $SESSION_FILE

echo "[notes]" >> $SESSION_FILE

```

Resume Session

```bash

# List recent sessions

ls -lt ~/.claude/sessions/ | head -10

# View session

cat ~/.claude/sessions/SESSION_ID.md

# Continue from last checkpoint

tail -50 ~/.claude/sessions/SESSION_ID.md

```

Checkpoint System

```bash

#!/bin/bash

# checkpoint.sh SESSION_ID DESCRIPTION

SESSION_FILE=~/.claude/sessions/$1.md

CHECKPOINT=$2

echo "" >> $SESSION_FILE

echo "## Checkpoint: $(date +%H:%M)" >> $SESSION_FILE

echo "Status: $CHECKPOINT" >> $SESSION_FILE

echo "Can resume from here." >> $SESSION_FILE

```

Milestone Tracking

```markdown

# Session Progress

• [x] M1: Environment setup
• [x] M2: Core implementation
• [ ] M3: Testing
• [ ] M4: Documentation

Completed

• Unit tests for auth module
• Integration test setup

In Progress

• API endpoint tests

Blocked

• Need test fixtures for edge cases

```

Save Important Context

```bash

#!/bin/bash

# save-context.sh SESSION_ID

SESSION_FILE=~/.claude/sessions/$1.md

cat >> $SESSION_FILE << 'CONTEXT'

File Locations

• Main entry: src/index.ts
• Config: src/config.ts
• Tests: tests/

Key Decisions

• Using JWT for auth (not sessions)
• PostgreSQL for persistence
• Redis for caching

Current State

• Auth module: complete
• API routes: 80% done
• Tests: 40% coverage

CONTEXT

```

Context Recovery

```bash

# Get context for resumption

CONTEXT=$(grep -A 50 "## Critical Context" ~/.claude/sessions/$SESSION_ID.md)

gemini -m pro -o text -e "" "I'm resuming a long coding session. Here's the context:

$CONTEXT

Help me remember:

1. Where was I?
2. What's the next step?
3. Any gotchas to remember?"

```

Get Your Bearings

```bash

#!/bin/bash

# bearings.sh - Where am I in this task?

echo "=== Current Session Status ==="

echo ""

# Git status

echo "### Git Status"

git status --short

echo ""

echo "### Recent Commits"

git log --oneline -5

echo ""

echo "### Modified Files"

git diff --stat HEAD~3

echo ""

echo "### TODO Items"

grep -r "TODO\|FIXME" src/ --include="*.ts" | head -10

```

Progress Summary

```bash

# Generate progress summary

gemini -m pro -o text -e "" "Summarize progress on this session:

Session log:

$(tail -100 ~/.claude/sessions/$SESSION_ID.md)

Git activity:

$(git log --oneline -10)

Provide:

1. What's been accomplished
2. Current status
3. Remaining work
4. Estimated completion"

```

Multi-Day Task

```markdown

# Multi-Day Task: [Name]

Accomplished

• [items]

Blocked

• [items]

Tomorrow

• [items]

---

Context from Yesterday

[summary]

Accomplished

• [items]

```

Handoff Document

When handing off to another session or agent:

```markdown

# Task Handoff

[Brief description]

• [Bullet points of where things stand]

• [Completed items]

• [Issues/blockers]

1. [Specific step]
2. [Specific step]

• src/main.ts - Entry point
• src/auth/ - Auth module (done)
• src/api/ - API routes (in progress)

```bash

npm run dev # Start development

npm test # Run tests

npm run build # Build for production

```

• [Things that might trip you up]

```

Feature Development

```bash

cat > ~/.claude/sessions/feature-template.md << 'EOF'

# Feature: [Name]

• [ ] Requirement 1
• [ ] Requirement 2

[Architecture notes]

• [ ] Step 1
• [ ] Step 2
• [ ] Step 3

• [ ] Unit tests
• [ ] Integration tests
• [ ] Manual testing

• [ ] Code comments
• [ ] README update
• [ ] API docs

EOF

```

Bug Fix

```bash

cat > ~/.claude/sessions/bugfix-template.md << 'EOF'

# Bug Fix: [Issue ID/Description]

[What's happening]

[What should happen]

• [ ] Reproduced locally
• [ ] Found root cause
• [ ] Identified fix

[Description of fix]

• [ ] Fix works
• [ ] No regressions
• [ ] Tests added

EOF

```

1. Log frequently - Update progress often
2. Save context - What would you need to resume?
3. Create checkpoints - Mark safe resume points
4. Summarize before breaks - Capture state of mind
5. Use templates - Consistent structure helps
6. Track blockers - Note what's waiting
7. Handoff cleanly - Assume fresh context next time