cross-session-memory
Use when you need to recover context, decisions, or artifacts across multiple Copilot CLI sessions — search prior session history and resume with the right files, notes, and state.
Install
npx skills add https://github.com/drvoss/everything-copilot-cli/tree/main/skills/copilot-exclusive/cross-session-memory
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install drvoss-everything-copilot-cli@llmmart
git clone https://github.com/drvoss/everything-copilot-cli.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole drvoss/everything-copilot-cli collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
Cross-Session Memory & Continuity
Why This is Copilot-Exclusive
Copilot CLI maintains a cross-session history store — a read-only SQLite database
(session_store) that contains conversation history, file references, and full-text search
across all your past sessions. Combined with /resume to continue previous sessions and
session artifacts stored in files/, this creates persistent memory across your development
workflow. Claude Code can also continue and resume sessions; this skill covers Copilot's own session history, artifacts, and Chronicle.
When to Use
- Resuming work on a multi-day task
- Searching past sessions for how you solved a similar problem before
- Building on artifacts (plans, analyses, configs) from previous sessions
- Maintaining context continuity across terminal restarts
- Reviewing what you accomplished in past sessions
Workflow
1. Resume a Previous Session
Use the /resume command to pick up where you left off:
/resume
This lists your recent sessions. Select one to continue with full context restored, including conversation history, file state, and session database.
2. Search Across Sessions
Option A: /chronicle for fast discovery
Start broad with natural-language history lookup:
/chronicle search authentication work from last week
/chronicle search Redis caching setup
/chronicle search payment module architecture decision
Use /chronicle search to find the most relevant sessions, decisions, or artifacts quickly. Once you
know which session matters, switch to SQL when you need exact filtering or reproducible queries.
Option B: SQL via session_store
Query the session_store database to find past work:
-- Prefer the search index for text lookup, then join back to sessions
sql(database: "session_store",
query: "
SELECT s.id, s.summary, si.source_type
FROM search_index si
JOIN sessions s ON s.id = si.session_id
WHERE search_index MATCH 'authentication OR auth OR login'
ORDER BY s.updated_at DESC
LIMIT 10
")
The session_store includes FTS5 (full-text search) for fast, fuzzy searching
across all your historical sessions.
Start broad, then narrow:
- search
search_indexwith expanded keywords - identify the relevant session IDs
- read the corresponding turns, checkpoints, or files in that session
If you query sessions directly, use it for structured metadata such as repository, branch, or
date range — not as your primary full-text search surface.
3. Access Session Artifacts
Files created during sessions are stored in the session's files/ directory:
~/.copilot/session-state/<session-id>/files/
These persist after the session ends and can be referenced in future sessions.
4. Session Database Continuity
When you resume a session, its SQL database is restored:
-- Check where you left off
SELECT id, title, status FROM todos ORDER BY updated_at DESC;
-- Continue from your last in-progress todo
SELECT * FROM todos WHERE status = 'in_progress';
5. Building Knowledge Over Time
Pattern: Evolving Architecture Documents
Session 1: "Analyze the codebase architecture and create a summary"
→ Produces architecture analysis in session artifacts
Session 2: /resume → "Update the architecture doc with the new payment module
we added last week"
→ Builds on previous analysis
Session 3: /resume → "Add the performance benchmarks we ran yesterday"
→ Continues evolving the document
Pattern: Progressive Refactoring
Session 1: Plan the refactoring (todos created in SQL)
Session 2: /resume → Execute Phase 1 (update todo statuses)
Session 3: /resume → Execute Phase 2 (pick up from SQL state)
Session 4: /resume → Final verification and cleanup
6. Trust Recalled Context Carefully
Anything recalled from an earlier session is a claim about the past, not a fact about the current code. Three habits keep it from quietly steering work in the wrong direction:
- Credit what you used. When a past session or artifact shapes an answer, name it — the session ID or date, or the artifact path — so the user can check it. Do not cite history that did not actually contribute to the answer.
- Record corrections instead of ignoring them. When recalled context turns out to be wrong or
stale once you check the code,
git, or an external source, write a short correction note: what the old note claimed, what is true now, the evidence you checked (with any token, key, or connection string redacted), and which note it supersedes.session_storeis read-only, so the correction belongs in a session artifact or in durable project documentation. Silently skipping the bad note leaves the same trap for the next session. - Keep one living note per initiative. When a plan is agreed, record it once with a status
(
active,done, orabandoned). When its goal, scope, or rationale changes materially, update that same note instead of starting a second one; small course corrections do not count.
Examples
Multi-Day Feature Development
# Day 1 - Monday
You: "Plan the new notification system"
Copilot: Creates plan, SQL todos, architecture notes
# Day 2 - Tuesday
/resume
You: "Continue with the notification system. Where did we leave off?"
Copilot: Reads SQL todos, sees Phase 1 is done, starts Phase 2
# Day 3 - Wednesday
/resume
You: "Let's finish the notification system and write tests"
Copilot: Picks up from Phase 2 completion, writes tests
Finding Past Solutions
You: "Last month I set up a Redis caching layer for something.
Search my past sessions for how I configured it."
sql(database: "session_store",
query: "
SELECT s.id, s.summary
FROM search_index si
JOIN sessions s ON s.id = si.session_id
WHERE search_index MATCH 'redis OR cache OR redis-cache OR caching'
ORDER BY s.updated_at DESC
LIMIT 5
")
Copilot finds the relevant session and extracts the configuration approach.
Reusing Analysis
You: "I did a security audit of the auth module a few weeks ago.
Find that analysis and check if the issues were fixed."
# Search past sessions
# Find the security audit
# Compare findings against current code
# Report which issues are resolved vs still open
Session Artifact Workflow
# Session 1: Generate a report
You: "Analyze test coverage gaps and create a report"
→ Report saved to session files/
# Session 2: Act on the report
/resume
You: "Now implement the missing tests from our coverage analysis"
→ Reads the report from session artifacts, generates tests
Durable Knowledge in a Worktree
For research notes or reference material that should outlive a single session but stay isolated from active code edits, keep them in a dedicated docs or notes worktree instead of mixing them into the main checkout.
Good uses:
- durable architecture summaries
- long-lived comparison notes
- reproducible research snapshots
Guardrails:
- treat that worktree as a read-mostly knowledge store
- verify the expected remote or target path before writing into it
- redact credentials, tokens, or connection URLs before saving logs or copied config
Tips
- Use /resume for continuity: Don't re-explain context. Resume picks up your full conversation and state.
- Start with /chronicle, drill with SQL: use
/chronicle searchfor fast discovery, then querysearch_indexor session tables when you need precision. - Name your sessions: Use descriptive first messages so sessions are easy to find later. "Set up payment processing" is better than "help me code."
- SQL todos survive sessions: Your
todostable persists when you resume. Use it as a persistent task tracker across days. - Session store is read-only: You can search
session_storebut not write to it. It's automatically populated from your session history. - Artifacts for important outputs: When Copilot generates something you'll need later (reports, configs, plans), it can save to session files.
- Use worktrees for durable reference sets: If the material should persist beyond one session and stay separate from product code edits, keep it in a dedicated worktree.
- Prefer structured retrieval over memory: search
search_index, then inspect matching turns or checkpoints instead of guessing from titles alone. - Search before you start: Before tackling a problem, search past sessions to see if you've solved something similar. Build on past work, don't repeat it.
Files (everything-copilot-cli)
-
SKILL.md 8.9 KB
--- name: cross-session-memory license: MIT description: Use when you need to recover context, decisions, or artifacts across multiple Copilot CLI sessions — search prior session history and resume with the right files, notes, and state. metadata: category: copilot-exclusive copilot_feature: "Session resume (/resume), /chronicle, session store (session_store database), session artifacts" --- # Cross-Session Memory & Continuity ## Why This is Copilot-Exclusive Copilot CLI maintains a **cross-session history store** — a read-only SQLite database (`session_store`) that contains conversation history, file references, and full-text search across all your past sessions. Combined with `/resume` to continue previous sessions and session artifacts stored in `files/`, this creates persistent memory across your development workflow. Claude Code can also continue and resume sessions; this skill covers Copilot's own session history, artifacts, and Chronicle. ## When to Use - Resuming work on a multi-day task - Searching past sessions for how you solved a similar problem before - Building on artifacts (plans, analyses, configs) from previous sessions - Maintaining context continuity across terminal restarts - Reviewing what you accomplished in past sessions ## Workflow ### 1. Resume a Previous Session Use the `/resume` command to pick up where you left off: ```text /resume ``` This lists your recent sessions. Select one to continue with full context restored, including conversation history, file state, and session database. ### 2. Search Across Sessions #### Option A: `/chronicle` for fast discovery Start broad with natural-language history lookup: ```text /chronicle search authentication work from last week /chronicle search Redis caching setup /chronicle search payment module architecture decision ``` Use `/chronicle search` to find the most relevant sessions, decisions, or artifacts quickly. Once you know which session matters, switch to SQL when you need exact filtering or reproducible queries. #### Option B: SQL via `session_store` Query the `session_store` database to find past work: ```sql -- Prefer the search index for text lookup, then join back to sessions sql(database: "session_store", query: " SELECT s.id, s.summary, si.source_type FROM search_index si JOIN sessions s ON s.id = si.session_id WHERE search_index MATCH 'authentication OR auth OR login' ORDER BY s.updated_at DESC LIMIT 10 ") ``` The `session_store` includes FTS5 (full-text search) for fast, fuzzy searching across all your historical sessions. Start broad, then narrow: 1. search `search_index` with expanded keywords 2. identify the relevant session IDs 3. read the corresponding turns, checkpoints, or files in that session If you query `sessions` directly, use it for structured metadata such as repository, branch, or date range — not as your primary full-text search surface. ### 3. Access Session Artifacts Files created during sessions are stored in the session's `files/` directory: ```text ~/.copilot/session-state/<session-id>/files/ ``` These persist after the session ends and can be referenced in future sessions. ### 4. Session Database Continuity When you resume a session, its SQL database is restored: ```sql -- Check where you left off SELECT id, title, status FROM todos ORDER BY updated_at DESC; -- Continue from your last in-progress todo SELECT * FROM todos WHERE status = 'in_progress'; ``` ### 5. Building Knowledge Over Time #### Pattern: Evolving Architecture Documents ```text Session 1: "Analyze the codebase architecture and create a summary" → Produces architecture analysis in session artifacts Session 2: /resume → "Update the architecture doc with the new payment module we added last week" → Builds on previous analysis Session 3: /resume → "Add the performance benchmarks we ran yesterday" → Continues evolving the document ``` #### Pattern: Progressive Refactoring ```text Session 1: Plan the refactoring (todos created in SQL) Session 2: /resume → Execute Phase 1 (update todo statuses) Session 3: /resume → Execute Phase 2 (pick up from SQL state) Session 4: /resume → Final verification and cleanup ``` ### 6. Trust Recalled Context Carefully Anything recalled from an earlier session is a claim about the past, not a fact about the current code. Three habits keep it from quietly steering work in the wrong direction: - **Credit what you used.** When a past session or artifact shapes an answer, name it — the session ID or date, or the artifact path — so the user can check it. Do not cite history that did not actually contribute to the answer. - **Record corrections instead of ignoring them.** When recalled context turns out to be wrong or stale once you check the code, `git`, or an external source, write a short correction note: what the old note claimed, what is true now, the evidence you checked (with any token, key, or connection string redacted), and which note it supersedes. `session_store` is read-only, so the correction belongs in a session artifact or in durable project documentation. Silently skipping the bad note leaves the same trap for the next session. - **Keep one living note per initiative.** When a plan is agreed, record it once with a status (`active`, `done`, or `abandoned`). When its goal, scope, or rationale changes materially, update that same note instead of starting a second one; small course corrections do not count. ## Examples ### Multi-Day Feature Development ```text # Day 1 - Monday You: "Plan the new notification system" Copilot: Creates plan, SQL todos, architecture notes # Day 2 - Tuesday /resume You: "Continue with the notification system. Where did we leave off?" Copilot: Reads SQL todos, sees Phase 1 is done, starts Phase 2 # Day 3 - Wednesday /resume You: "Let's finish the notification system and write tests" Copilot: Picks up from Phase 2 completion, writes tests ``` ### Finding Past Solutions ```text You: "Last month I set up a Redis caching layer for something. Search my past sessions for how I configured it." sql(database: "session_store", query: " SELECT s.id, s.summary FROM search_index si JOIN sessions s ON s.id = si.session_id WHERE search_index MATCH 'redis OR cache OR redis-cache OR caching' ORDER BY s.updated_at DESC LIMIT 5 ") ``` Copilot finds the relevant session and extracts the configuration approach. ### Reusing Analysis ```text You: "I did a security audit of the auth module a few weeks ago. Find that analysis and check if the issues were fixed." # Search past sessions # Find the security audit # Compare findings against current code # Report which issues are resolved vs still open ``` ### Session Artifact Workflow ```text # Session 1: Generate a report You: "Analyze test coverage gaps and create a report" → Report saved to session files/ # Session 2: Act on the report /resume You: "Now implement the missing tests from our coverage analysis" → Reads the report from session artifacts, generates tests ``` ### Durable Knowledge in a Worktree For research notes or reference material that should outlive a single session but stay isolated from active code edits, keep them in a dedicated docs or notes worktree instead of mixing them into the main checkout. Good uses: - durable architecture summaries - long-lived comparison notes - reproducible research snapshots Guardrails: - treat that worktree as a read-mostly knowledge store - verify the expected remote or target path before writing into it - redact credentials, tokens, or connection URLs before saving logs or copied config ## Tips - **Use /resume for continuity**: Don't re-explain context. Resume picks up your full conversation and state. - **Start with /chronicle, drill with SQL**: use `/chronicle search` for fast discovery, then query `search_index` or session tables when you need precision. - **Name your sessions**: Use descriptive first messages so sessions are easy to find later. "Set up payment processing" is better than "help me code." - **SQL todos survive sessions**: Your `todos` table persists when you resume. Use it as a persistent task tracker across days. - **Session store is read-only**: You can search `session_store` but not write to it. It's automatically populated from your session history. - **Artifacts for important outputs**: When Copilot generates something you'll need later (reports, configs, plans), it can save to session files. - **Use worktrees for durable reference sets**: If the material should persist beyond one session and stay separate from product code edits, keep it in a dedicated worktree. - **Prefer structured retrieval over memory**: search `search_index`, then inspect matching turns or checkpoints instead of guessing from titles alone. - **Search before you start**: Before tackling a problem, search past sessions to see if you've solved something similar. Build on past work, don't repeat it.
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.