SkillAgentSearch skills...

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-ingest

Installs into whichever agent you are using.

About this skill
šŸ“„

SKILL.md

Installable skill definition

Quality Score

95/100

Supported Platforms

GitHub Copilot

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.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
15/20
Freshness
15/15

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.

SkillScoreStarsUpdatedFormat
copilot-history-ingest (this skill)by Ar9av953.5k54d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.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.

name: 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.

  1. Resolve config — follow the Config Resolution Protocol in llm-wiki/SKILL.md (inline @name override → walk up CWD for .env → global config → prompt setup). This gives OBSIDIAN_VAULT_PATH, COPILOT_HISTORY_PATH (defaults to ~/.copilot/session-state), and COPILOT_VSCODE_STORAGE_PATH (VS Code workspaceStorage; platform-specific — ask the user if absent)
  2. Read .manifest.json at the vault root to check what's already been ingested
  3. Read index.md at 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_at is newer than their ingested_at in 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:

  1. Checkpoints (session-store.db checkpoints table + per-session checkpoints/*.json) — Pre-distilled summaries with overview, work_done, technical_details, important_files, next_steps. Gold.
  2. Session summaries (session-store.db sessions.summary + index.md) — One-paragraph synopsis per session.
  3. Turns (session-store.db turns table + events.jsonl / transcript JSONL) — Full conversation. Rich but verbose.
  4. Memory artifacts (memory-tool/memories/<id>/plan.md etc.) — Pre-written plans and structured notes the user saved explicitly. Worth importing verbatim (or lightly summarised).
  5. File access patterns (session_files table + tool.execution_* events) — Which files the agent repeatedly touched — reveals high-value project files.
  6. Session refs (session_refs table) — Commits, PRs, and issues linked to sessions.
  7. 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_at is 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 accomplished
  • work_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.content is the assistant's text response — extract this
  • data.reasoningText is internal reasoning — skip (it's the unpacked reasoningOpaque field)
  • data.toolRequests lists 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 / repository give you a natural first-level grouping; vscode.metadata.json's customTitle gives 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

View on GitHub
GitHub Stars3.5k
CategoryDevelopment
Updated1mo ago
Forks345

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions
copilot-history-ingest — GitHub Copilot Skill: Install & Safety Check | SkillAgent