[Feature Request] Native session continuity — structured handoff across conversations

[Feature Request] Native session continuity — structured handoff across conversations

The problem

Claude Code has no memory between conversations. Every new session starts cold — no knowledge of what was planned, what was completed, or what comes next. Context compaction makes this worse: even within a long conversation, history silently disappears.

For serious development work across days or weeks, this is the biggest friction point. Users are left to either:

• Keep one enormous conversation alive (fragile, gets compacted)
• Re-explain context at the start of every session (tedious, error-prone)
• Build their own workaround (which is exactly what we did)

What we built as a workaround

We implemented a session handoff system entirely through ~/.claude/CLAUDE.md instructions. It works, it's been tested, and it's genuinely useful — but it requires significant manual scaffolding and has one fundamental limitation that only a native feature can solve.

How it works

At conversation end, Claude writes a structured handoff file to .claude/sessions/<session-id>/handoff.md:

# Session: pm_dev
# Saved: 2026-05-23

## Sequence plan
- [x] Implement report layer
- [x] Add `show allocation` derived view  
- [>] Polish HTML report
- [ ] Extract Jinja2 template
- [ ] Implement `update narrative` command

## Current piece
Polishing the HTML report. Identified 11 issues, prioritized bugs first.

## Next piece
Fix empty <tbody> in issuer concentration and maturity ladder tables.
Tools: Edit. Files: docs/generated/mama_report_20260522.html
Estimate: 5 min.

## Open questions / blockers
Should Holdings + Performance merge into one table?

At conversation start, Claude scans .claude/sessions/*/handoff.md, presents a numbered session picker, and loads the chosen session — restoring the full sequence plan with visual status indicators (✅ done, ▶ current, ☐ planned, ❌ failed).

Multiple sessions can coexist, enabling parallel workstreams (e.g. pm_dev, headless, remote_push).

What works well

• The sequence plan as a project dashboard — show plan at any point gives a full picture of past and future work
• Auto-write after execution — state is always persisted even if the user doesn't think to save
• Git-committed — the plan history is version-controlled alongside the code
• Session renaming, plan updates, and handoff/resume as natural-language commands all work as expected
• Supports the planning/execution model: break work into 5-10 min headless pieces, each piece tracked in the plan

The fundamental limitation

There is no conversation-start hook. Claude can only act in response to a user message. The user must send something (we use "hello") to trigger the session picker. A native implementation could fire automatically the moment a conversation opens — zero friction.

Proposed native feature

1. Conversation-start hook

A hook that fires before the first user message is processed, allowing Claude to present the session picker immediately on conversation open — no user trigger required.

// settings.json
{
  "hooks": {
    "ConversationStart": [
      { "type": "session-resume" }
    ]
  }
}

2. Native session storage

First-class .claude/sessions/<id>/ directories with a defined schema, managed by Claude Code rather than ad-hoc markdown files. Benefits:

• Survives context compaction (stored outside conversation history)
• Indexed and queryable
• Could integrate with the Claude Code UI (session switcher in sidebar)

3. Structured plan tracking

The sequence plan — with piece status, current piece, next piece, blockers — as a native concept rather than freeform markdown. This enables:

• Visual progress indicators in the UI
• Time estimates and actual duration tracking
• Integration with git (auto-commit plan state alongside code changes)

4. Auto-write trigger

A PostExecution hook that writes the handoff automatically after each headless execution piece completes (or fails), without requiring an explicit handoff command.

Why this matters

The planning/execution model — where a human plans interactively and Claude executes headlessly while the human takes a break — is one of the most powerful workflows Claude Code enables. But it depends entirely on reliable session continuity. Right now, users who want this workflow have to build and maintain their own continuity infrastructure in CLAUDE.md. That's a significant barrier.

Native session continuity would make this workflow accessible to every Claude Code user, not just those willing to invest in the scaffolding.

Current workaround (for reference)

The full working implementation lives in ~/.claude/CLAUDE.md as natural-language instructions to Claude. It handles: auto-resume on greeting, session picker UI, handoff/resume commands, auto-write after execution, multi-session support, and plan rendering with status indicators. It required approximately one hour of interactive design with Claude to get right — which is evidence both that it's achievable and that it shouldn't require that investment from every user.

---

Tested on Claude Sonnet 4.6, May 2026. The workaround is production-stable but the missing hook remains a real limitation.