copilot-history-ingest
Ingest GitHub Copilot CLI/session history into Obsidian as distilled knowledge. Use for importing or mining Copilot history; not for general Copilot help, simple session search, or backup.
Install / Use
npx skills add Ar9av/obsidian-wiki --skill copilot-history-ingestInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of copilot-history-ingest
copilot-history-ingest scores 95/100 on our quality scale, 373rd of 4,700 Development & Engineering skills we index (top 8%).
Its SKILL.md is 18 KB long, well organised into 38 sections with 16 code examples: a thorough specification that gives an agent plenty to work with.
With 3,485 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so copilot-history-ingest is actively maintained.
- Our last check on 2026-11-16 could not reach the source (HTTP 404); it may have been moved or deleted.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit ā read the skill file before letting an agent act on it.
copilot-history-ingest compared with similar skills
All 4 of these similar skills score higher than copilot-history-ingest; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| copilot-history-ingest (this skill)by Ar9av | 95 | 3.5k | 54d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
Frequently asked questions
- How do I install copilot-history-ingest?
- Run
npx skills add Ar9av/obsidian-wiki --skill copilot-history-ingest. The install tabs above show the steps for each supported agent. - Which AI agents does copilot-history-ingest work with?
- It is written for GitHub Copilot, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is copilot-history-ingest safe to use?
- It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is copilot-history-ingest still maintained?
- The repository was last updated about 2 months ago, so copilot-history-ingest is actively maintained.
Skill content
View source on GitHubname: copilot-history-ingest description: > Ingest GitHub Copilot CLI/session history into Obsidian as distilled knowledge. Use for importing or mining Copilot history; not for general Copilot help, simple session search, or backup.
Copilot History Ingest ā Conversation Mining
You are extracting knowledge from the user's past GitHub Copilot CLI conversations and distilling it into the Obsidian wiki. Conversations are rich but messy ā your job is to find the signal and compile it.
This skill can be invoked directly or via the wiki-history-ingest router (/wiki-history-ingest copilot).
Before You Start
Writing profile: Before drafting or rewriting natural-language Markdown, read and apply the Writing Profile Resolution section in llm-wiki/SKILL.md. Framework schema, provenance, safety, and operation-specific requirements take precedence.
WRITING.md preferences apply only to newly drafted or rewritten natural-language Markdown; preserve source content and structured records.
- Resolve config ā follow the Config Resolution Protocol in
llm-wiki/SKILL.md(inline@nameoverride ā walk up CWD for.envā global config ā prompt setup). This givesOBSIDIAN_VAULT_PATH,COPILOT_HISTORY_PATH(defaults to~/.copilot/session-state), andCOPILOT_VSCODE_STORAGE_PATH(VS CodeworkspaceStorage; platform-specific ā ask the user if absent) - Read
.manifest.jsonat the vault root to check what's already been ingested - Read
index.mdat the vault root to know what the wiki already contains
Ingest Modes
Append Mode (default)
Check .manifest.json for each source file (events JSONL, transcript JSONL, checkpoint, session-store DB). Only process:
- Sessions not in the manifest (new sessions)
- Sessions whose
updated_atis newer than theiringested_atin the manifest
This is usually what you want ā the user ran a few new sessions and wants to capture the delta.
Full Mode
Process everything regardless of manifest. Use after a wiki-rebuild or if the user explicitly asks.
GitHub Copilot Data Layout
Copilot stores data in three locations. Scan all three.
Source 1: ~/.copilot/session-state/ (CLI sessions)
~/.copilot/session-state/
āāā <session-uuid>/
ā āāā workspace.yaml # Session metadata (id, cwd, summary_count, created_at, updated_at)
ā āāā vscode.metadata.json # VS Code context (workspaceFolder, repositoryProperties, customTitle)
ā āāā events.jsonl # Full event log ā all turns, tool calls, reasoning
ā āāā session.db # Per-session SQLite (todos/todo_deps only ā skip for ingestion)
ā āāā index.md # Session summary written at session end
ā āāā checkpoints/ # Checkpoint JSON files (mid-session summaries)
ā ā āāā <uuid>.json # title, overview, history, work_done, technical_details,
ā ā # important_files, next_steps
ā āāā files/ # Artifacts produced during session (plans, diagrams, etc.)
ā āāā research/ # Research artifacts
āāā ...
Source 2: ~/.copilot/session-store.db (Global SQLite)
The canonical cross-session database. This is the highest-value source: structured, queryable, and pre-summarised.
sessions ā id, cwd, repository, branch, summary, created_at, updated_at, host_type
turns ā session_id, turn_index, user_message, assistant_response, timestamp
checkpoints ā session_id, checkpoint_number, title, overview, history, work_done,
technical_details, important_files, next_steps, created_at
session_files ā session_id, file_path, tool_name, turn_index, first_seen_at
session_refs ā session_id, ref_type (commit/pr/issue), ref_value, turn_index, created_at
search_index ā FTS5 virtual table (content, session_id, source_type, source_id)
Source 3: VS Code Workspace Storage (<workspaceStorage>/<hash>/GitHub.copilot-chat/)
VS Code extension data, keyed by workspace hash. The path is platform-specific and must come from .env or user input.
<hash>/GitHub.copilot-chat/
āāā transcripts/
ā āāā <session-uuid>.jsonl # Conversation transcripts (same JSONL format as events.jsonl)
āāā memory-tool/
ā āāā memories/
ā āāā <base64-session-id>/ # Per-session saved artifacts (plan.md, etc.)
ā āāā plan.md
āāā codebase-external.sqlite # Codebase index (skip ā no conversation knowledge)
Key data sources ranked by value:
- Checkpoints (
session-store.dbcheckpointstable + per-sessioncheckpoints/*.json) ā Pre-distilled summaries withoverview,work_done,technical_details,important_files,next_steps. Gold. - Session summaries (
session-store.dbsessions.summary+index.md) ā One-paragraph synopsis per session. - Turns (
session-store.dbturnstable +events.jsonl/ transcript JSONL) ā Full conversation. Rich but verbose. - Memory artifacts (
memory-tool/memories/<id>/plan.mdetc.) ā Pre-written plans and structured notes the user saved explicitly. Worth importing verbatim (or lightly summarised). - File access patterns (
session_filestable +tool.execution_*events) ā Which files the agent repeatedly touched ā reveals high-value project files. - Session refs (
session_refstable) ā Commits, PRs, and issues linked to sessions. vscode.metadata.jsonā Workspace folder path, branch,customTitle(user-set session label). Useful for grouping and naming.
Step 1: Survey and Compute Delta
Scan all three data locations and compare against .manifest.json:
# --- Source 1: per-session directories ---
# Find all session directories (each has workspace.yaml)
ls ~/.copilot/session-state/
# For each session, read workspace.yaml for id/cwd/updated_at
# and vscode.metadata.json for customTitle / repositoryProperties
# --- Source 2: global database ---
# Query session-store.db with sqlite3 (or Python sqlite3)
SELECT s.id, s.cwd, s.repository, s.branch, s.summary, s.updated_at,
COUNT(DISTINCT t.turn_index) AS turn_count,
COUNT(DISTINCT c.id) AS checkpoint_count
FROM sessions s
LEFT JOIN turns t ON t.session_id = s.id
LEFT JOIN checkpoints c ON c.session_id = s.id
GROUP BY s.id
ORDER BY s.updated_at DESC;
# --- Source 3: VS Code workspace storage ---
# For each <hash> directory under workspaceStorage, check for GitHub.copilot-chat/
# Find transcript files
ls <workspaceStorage>/<hash>/GitHub.copilot-chat/transcripts/
Build a unified inventory ā one entry per session UUID ā and classify:
- New ā not in manifest ā needs ingesting
- Modified ā in manifest but
updated_atis newer ā needs re-ingesting - Unchanged ā in manifest and not modified ā skip in append mode
Report to the user: "Found X sessions in session-state, Y in session-store.db, Z VS Code transcript files. Checkpoints: A. Delta: B new, C modified."
Step 2: Ingest Checkpoints and Summaries First
Checkpoints are already distilled ā process them before touching raw turns.
From session-store.db:
SELECT s.id, s.cwd, s.repository, s.branch, s.summary,
c.checkpoint_number, c.title, c.overview, c.work_done,
c.technical_details, c.important_files, c.next_steps,
c.created_at
FROM checkpoints c
JOIN sessions s ON c.session_id = s.id
ORDER BY s.updated_at DESC, c.checkpoint_number ASC;
From per-session checkpoints/*.json:
Each checkpoint file has: title, overview, history, work_done, technical_details, important_files, next_steps.
Read index.md (if present) as a session-level summary ā it's typically written at session end and is already concise.
What to extract:
overviewā high-level description of what the session accomplishedwork_doneā concrete tasks completed (good for skills / project pages)technical_detailsā implementation specifics (good for concepts pages)important_filesā high-value files in the project (good for project pages)next_stepsā open threads (good for linking to ongoing project work)
Step 3: Parse Session Turns
Read turns from session-store.db (preferred ā already parsed) or from events.jsonl / transcript JSONL.
From session-store.db:
SELECT turn_index, user_message, assistant_response, timestamp
FROM turns
WHERE session_id = '<uuid>'
ORDER BY turn_index ASC;
From events.jsonl / transcript JSONL:
Each file is one session. Each line is a JSON event. See references/copilot-data-format.md for the full schema.
Relevant event types:
| type | What it is | Worth reading? |
| --------------------- | --------------------------------------- | ----------------------------------------- |
| session.start | Session metadata (cwd, branch, version) | Yes ā establishes project context |
| user.message | User turn | Yes ā data.content |
| assistant.message | Assistant turn | Yes ā data.content (text) + data.toolRequests |
| tool.execution_start| Tool call | Skim ā reveals what files/commands were used |
| tool.execution_end | Tool result | No ā usually noise |
Extraction strategy for assistant.message:
data.contentis the assistant's text response ā extract thisdata.reasoningTextis internal reasoning ā skip (it's the unpackedreasoningOpaquefield)data.toolRequestslists tool calls ā skim tool names and arguments for file access patterns- Skip
type: "tool.execution_end"entirely
Step 3b: Process Memory Artifacts
For each session that has a memory-tool/memories/<base64-id>/ directory in VS Code workspace storage, read any markdown files saved there (typically plan.md). These are documents the user explicitly saved ā treat them as high-quality, user-authored content.
Decode the base64 directory name to get the session UUID:
import base64
session_id = base64.b64decode(dir_name).decode('utf-8')
Memory artifacts map to project skills/ or concepts/ pages, depending on content type.
Step 3c: Extract File and Ref Patterns
From session-store.db:
-- Most-touched files per project
SELECT repository, file_path, COUNT(*) AS touch_count
FROM session_files
GROUP BY repository, file_path
ORDER BY touch_count DESC;
-- Linked commits/PRs/issues per session
SELECT session_id, ref_type, ref_value, turn_index
FROM session_refs
ORDER BY session_id, turn_index;
File access patterns reveal which files are architecturally important ā note them on project pages.
Session refs link Copilot sessions to git history ā useful for connecting wiki knowledge to concrete code changes.
Step 4: Cluster by Topic
Don't create one wiki page per session. Instead:
- Group extracted knowledge by topic across sessions
- A single session about "debugging auth + setting up CI" ā two separate topics
- Three sessions across different days about "React performance" ā one merged topic
cwd/repositorygive you a natural first-level grouping;vscode.metadata.json'scustomTitlegives a human-readable session label
Step 5: Distill into Wiki Pages
Dates: follow wiki-ingest's event-time rules. Resolve relative dates ("yesterday", "last week") against the session/message timestamp, never today, and when a newer session contradicts an existing page, invalidate the old claim (## History or valid_until + superseded_by) rather than overwriting it.
Each Copilot project maps to a project directory in the vault. Derive the project name from cwd or repository:
C:\Users\name\git\my-project ā my-project
/Users/name/code/another-app ā another-app
Prefer repository (e.g., owner/repo) from session-store.db o
Truncated for display ā read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu ā one CLI, zero API fees.
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code ā from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit ā see the Safety scan above for what the skill file itself contains.
