tellent

Appearance

Resume Work ​

You are tasked with resuming previously saved work by restoring full context and continuing implementation.

When to Use This Command ​

Invoke this when:

  • Returning to a previously paused feature
  • Starting a new session on existing work
  • Switching back to a saved task
  • Recovering from an interrupted session

Process ​

Step 1: Load Session Context ​

  1. Read session summary if provided:

    /rpi:resume_work
> .ai/thoughts/shared/sessions/2025-01-06_user_management.md

  2. Or discover recent sessions:

    bash
    ls -la .ai/thoughts/shared/sessions/
# Show user recent sessions to choose from

Step 2: Restore Full Context ​

Read in this order:

  1. Session summary - Understand where we left off
  2. Implementation plan - See overall progress
  3. Research document - Refresh technical context
  4. Recent commits - Review completed work
bash
# Check current state
git status
git log --oneline -10

# Check for stashed work
git stash list

Step 3: Rebuild Mental Model ​

Create a brief context summary:

markdown
## Resuming: [Feature Name]

### Where We Left Off
- Working on: [Specific task]
- Phase: [X of Y]
- Last action: [What was being done]

### Current State
- [ ] Tests passing: [status]
- [ ] Build successful: [status]
- [ ] Uncommitted changes: [list]

### Immediate Next Steps
1. [First action to take]
2. [Second action]
3. [Continue with plan phase X]

Step 4: Restore Working State ​

  1. Apply any stashed changes:

    bash
    git stash pop stash@{n}

  2. Verify environment:

    bash
    # Run tests to check current state
npm test
# or
make test

  3. Load todos:

    • Restore previous todo list
    • Update with current tasks

Step 5: Continue Implementation ​

Based on the plan's checkboxes:

markdown
# Identify first unchecked item
Looking at the plan, I need to continue with:
- [ ] Phase 2: API endpoints
  - [x] GET endpoints
  - [ ] POST endpoints <- Resume here
  - [ ] DELETE endpoints

Let me start by implementing the POST endpoints...

Step 6: Communicate Status ​

Tell the user:

markdown
Context restored successfully!

Resuming: [Feature Name]
Current Phase: [X of Y]
Next Task: [Specific task]

Previous session:
- Duration: [X hours]
- Completed: [Y tasks]
- Remaining: [Z tasks]

I'll continue with [specific next action]...

Resume Patterns ​

Pattern 1: Quick Resume (Same Day) ​

markdown
/rpi:resume_work
> Continue the user management feature from this morning

# Claude:
1. Finds most recent session
2. Reads plan to see progress
3. Continues from last checkbox

Pattern 2: Full Context Restore (Days Later) ​

markdown
/rpi:resume_work
> .ai/thoughts/shared/sessions/2025-01-03_auth_refactor.md

# Claude:
1. Reads full session summary
2. Reviews related research
3. Checks git history since then
4. Rebuilds complete context
5. Continues implementation

Pattern 3: Investigate and Resume ​

markdown
/rpi:resume_work
> What was I working on last week? Find and continue it.

# Claude:
1. Lists recent sessions
2. Shows git branches with recent activity
3. Presents options to user
4. Resumes chosen work

Integration with Framework ​

This command connects with:

  • /rpi:save_progress - Reads saved progress
  • /rpi:implement_plan - Continues implementation
  • /rpi:research_codebase - Refreshes understanding if needed
  • /rpi:validate_plan - Checks what's been completed

Advanced Features ​

Handling Conflicts ​

If the codebase changed since last session:

  1. Check for conflicts with current branch
  2. Review changes to related files
  3. Update plan if needed
  4. Communicate impacts to user

Session Comparison ​

markdown
## Changes Since Last Session
- New commits: [list]
- Modified files: [that affect our work]
- Team updates: [relevant changes]
- Plan updates: [if any]

Recovery Mode ​

If session wasn't properly saved:

  1. Use git reflog to find work
  2. Check editor backup files
  3. Review shell history
  4. Reconstruct from available evidence

Important Guidelines ​

  • Always verify state before continuing
  • Run tests first to ensure clean slate
  • Communicate clearly about what's being resumed
  • Update stale plans if codebase evolved
  • Check for blockers that may have been resolved
  • Refresh context fully - don't assume memory

Success Criteria ​

A successful resume should:

  • [ ] Load all relevant context
  • [ ] Identify exact continuation point
  • [ ] Restore working environment
  • [ ] Continue seamlessly from pause point
  • [ ] Maintain plan consistency
  • [ ] Preserve all previous decisions