claude-attribution 1.8.0 → 1.9.4

package/README.md

@@ -1,12 +1,12 @@
 # claude-attribution
 
-AI code attribution for Claude Code. After every `git commit`, a one-line summary appears in your terminal:
+AI code attribution for Claude Code and GitHub Copilot. After every `git commit`, a one-line summary appears in your terminal:
 
 ```
 [claude-attribution] a3f1b2c — 142 AI / 38 human / 4 mixed lines (77% AI)
 ```
 
-When a PR is opened, full metrics — model usage, token counts, tool calls, and attribution percentages — are injected automatically into the PR body. No copy-paste, no manual tracking.
+When a PR is opened, full metrics — model usage, token counts when available, tool calls, and attribution percentages — are injected automatically into the PR body. No copy-paste, no manual tracking.
 
 **Quick start:**
 
@@ -19,13 +19,13 @@ git commit -m "chore: install claude-attribution hooks"
 git push
 ```
 
-**Using Copilot or `@claude` (claude-code-action)?** Bot commits are auto-detected and attributed as 100% AI — no extra steps needed. See [AI Actor Attribution](#ai-actor-attribution-copilot-bot-claude-gha).
+**Using Copilot or `@claude` (claude-code-action)?** Local Copilot CLI sessions are parsed from `~/.copilot/session-state/...`, and bot commits are auto-detected as 100% AI when no local session data exists. See [Copilot CLI Support](#copilot-cli-support) and [AI Actor Attribution](#ai-actor-attribution-copilot-bot-claude-gha).
 
 **Requirements:** [Bun](https://bun.sh) (preferred) or Node 18+, and `gh` (GitHub CLI) authenticated for the `/pr` command.
 
 ---
 
-Measures which lines in a commit were written by Claude vs. a human — using checkpoint snapshots and line-level SHA-256 comparison, not gross write-operation counts.
+Measures which lines in a commit were written by an AI assistant vs. a human — using checkpoint snapshots and line-level SHA-256 comparison when available, with explicit fallbacks for Copilot CLI sessions and hosted AI bot commits.
 
 ---
 
@@ -68,6 +68,51 @@ Up to three workflows are installed into repos that use this tool — one always
 
 ---
 
+## Publishing this package to npm
+
+This repo is set up to publish to npm from GitHub Actions on the **self-hosted runner** using an npm publish token. That avoids local OTP prompts while still fitting the repo's network restrictions.
+
+### One-time npm + GitHub setup
+
+This part must be done by a package owner:
+
+1. In npm, open the `claude-attribution` package and set **Publishing access** to **Require two-factor authentication or a granular access token with bypass 2fa enabled**.
+2. Create a **granular npm access token** that can publish `claude-attribution` and has **bypass 2FA** enabled.
+3. In GitHub, save that token as the `NPM_TOKEN` Actions secret for this repository (or an org secret exposed to this repo).
+4. Optional: you can leave the npm trusted publisher entry in place, but this self-hosted workflow authenticates with `NPM_TOKEN`.
+5. Plan to rotate the npm token periodically. npm currently caps granular token lifetime at 90 days.
+
+After that, the workflow in `.github/workflows/publish-npm.yml` can publish on the self-hosted runner without an interactive OTP prompt.
+
+### Release process
+
+This repo uses a **bump → merge → tag** publish flow:
+
+1. Bump `package.json` to the release version and update `CHANGELOG.md` in the PR.
+2. Merge that PR to `main`.
+3. Tag the merged commit from `main`:
+
+```bash
+git checkout main
+git pull --ff-only
+git tag v1.9.1
+git push origin v1.9.1
+```
+
+4. GitHub Actions runs `publish-npm.yml` and publishes that exact version to npm.
+
+### Important rules
+
+- The git tag must exactly match `package.json` without the `v` prefix.
+  - Example: tag `v1.9.1` requires `"version": "1.9.1"` in `package.json`
+- The workflow fails if the tag and package version do not match.
+- The workflow also fails if that package version is already published.
+- `NPM_TOKEN` must exist in GitHub Actions before the tag is pushed.
+- The npm token must be a granular publish token with bypass-2FA enabled for this package.
+- The self-hosted workflow publishes **without** `--provenance` because npm only accepts provenance from GitHub-hosted runners.
+
+---
+
 ## For Repo Maintainers: Installing Into a Repo
 
 ### Prerequisites
@@ -164,7 +209,7 @@ git push origin refs/notes/claude-attribution-map
 Marks every currently tracked file as AI-written at HEAD. After this, PR metrics will show:
 ```
 Codebase: ~100% AI (4150 / 4150 lines)
-This PR: 184 lines changed (4% of codebase) · 77% Claude edits · 142 AI lines
+This PR: 184 lines changed (4% of codebase) · 77% AI edits · 142 AI-attributed changed lines
 ```
 
 **Option 2 — Repo is human-written, or a mix (`--human` / no flag):**
@@ -188,7 +233,7 @@ If you reinstall `claude-attribution` globally (e.g. after upgrading), you can n
 claude-attribution update
 ```
 
-The installer records each repo in a per-user registry at `~/.claude/claude-attribution/installed-repos.json`. `update` re-runs the installer for every still-valid tracked repo, skips repos already on the current CLI version, and prunes paths that no longer exist or are no longer git repos.
+The installer records each repo installed with `claude-attribution` v1.8.0 or later in a per-user registry at `~/.claude/claude-attribution/installed-repos.json`. `update` re-runs the installer for every still-valid tracked repo in that registry, skips repos already on the current CLI version, and prunes paths that no longer exist or are no longer git repos. Repos installed before v1.8.0 will not appear there until you run `claude-attribution install` for them once on the newer CLI.
 
 To force a reinstall even when the recorded version already matches, use:
 
@@ -242,33 +287,43 @@ Metrics are injected automatically — no command needed.
 
 **When Claude creates the PR** (asks Claude to open a PR, uses `/pr`): the `post-bash` hook fires immediately after `gh pr create` succeeds, injects full local metrics (token usage, tool counts, attribution) into the PR body before Claude continues.
 
-**When you create the PR yourself** (`gh pr create`, GitHub UI, Copilot): the `claude-attribution-pr.yml` GitHub Actions workflow fires on `opened` and injects attribution-only metrics (token counts aren't available in CI since logs are local).
+**When you create the PR yourself** (`gh pr create`, GitHub UI, Copilot): the `claude-attribution-pr.yml` GitHub Actions workflow fires on `opened` and rebuilds metrics from durable git notes when available. If only CI-visible data exists, it falls back to attribution-only metrics because local session logs are not available in CI.
 
 **On every new push to an open PR**: the workflow fires on `synchronize` and updates the attribution percentages to reflect new commits.
 
 The metrics block injected into the PR body looks like (when the cumulative minimap exists):
 
-> ## Claude Code Metrics
+> ## AI Coding Metrics
 >
 > **Codebase: ~77% AI** (3200 / 4150 lines)
-> **This PR:** 184 lines changed (4% of codebase) · 77% Claude edits · 142 AI lines · Active: 8m
+> **This PR:** 184 lines changed (4% of codebase) · 77% AI edits · 142 AI-attributed changed lines
+> **Session:** 12 prompts · 24m total (18m AI · 6m human)
+> **Assistant runtime:** Claude Code (claude-sonnet-4-6)
 >
 > | Model | Calls | Input | Output | Cache |
 > |-------|-------|-------|--------|-------|
 > | Sonnet | 45 | 120K | 35K | 10K |
 > | **Total** | 45 | 120K | 35K | 10K |
 >
-> **Human prompts (steering effort):** 12
+> **Estimated cost:** ~$1.23
 >
 > <details><summary>Tools · Agents · Files</summary>
 >
-> **Tools:** Edit ×47, Read ×31, Bash ×12
+> **External tools:** WebSearch ×2
 >
 > </details>
 
 Before running `init --ai` (or on a fresh install with no minimap), the headline falls back to the session-only view:
 
-> **AI contribution: ~77%** (142 of 184 committed lines) · Active: 8m
+> **AI contribution: ~77%** (142 of 184 committed lines)
+
+For **Copilot CLI** sessions, the same block is rendered with provider-aware differences:
+
+- assistant runtime shows as `GitHub Copilot CLI`
+- model usage shows **Known Tokens** instead of Claude-style input/output/cache columns
+- cost is shown as **unavailable** unless durable local billing data exists
+
+The `This PR` line is based on the branch diff against the base branch, not the full final size of every touched file.
 
 The block is wrapped in HTML comments for idempotent updates — re-running replaces the existing block rather than appending:
 
@@ -301,31 +356,19 @@ claude-attribution metrics
 The output is markdown you paste into your PR description:
 
 ```markdown
-## Claude Code Metrics
-
-**Session ID:** `abc-123-...`
+## AI Coding Metrics
 
-### Tools Used
-- **Edit:** 47 calls
-- **Read:** 31 calls
-...
+**Codebase: ~77% AI** (3200 / 4150 lines)
+**This PR:** 184 lines changed (4% of codebase) · 77% AI edits · 142 AI lines
+**Session:** 12 prompts · 24m total (18m AI · 6m human)
+**Assistant runtime:** GitHub Copilot CLI (v1.0.15 · gpt-5.4)
 
-### Model Usage
-| Model | API Calls | Input Tokens | Output Tokens | Cache Tokens |
-...
+| Model | Calls | Known Tokens |
+|-------|-------|--------------|
+| gpt-5.4 | 12 | 48K |
+| **Total** | 12 | 48K |
 
-**Human prompts (steering effort):** 12
-
-### Code Attribution
-- **AI-authored lines:** 142
-- **Human-authored lines:** 38
-- **Mixed lines (AI wrote, human modified):** 4
-- **Total committed lines:** 184
-- **AI contribution:** ~77%
-
-#### Files Modified by Claude
-- `src/components/Foo.tsx` — 89% AI (82 lines)
-- `src/hooks/useBar.ts` — 61% AI (44 lines)
+**Estimated cost:** unavailable — Copilot session data does not expose enough local billing data to estimate spend reliably.
 ```
 
 ### Running with a specific session ID
@@ -336,7 +379,35 @@ If you have multiple sessions and want metrics for a specific one:
 claude-attribution metrics <session-id>
 ```
 
-Session IDs are shown in `.claude/logs/tool-usage.jsonl`.
+Claude session IDs are shown in `.claude/logs/tool-usage.jsonl`. Copilot CLI session IDs are the directory names under `~/.copilot/session-state/`.
+
+### Copilot CLI support
+
+`claude-attribution` now supports **local GitHub Copilot CLI sessions** without adding a separate Copilot-specific install flow.
+
+How it works:
+
+1. The existing repo install still provides the post-commit hook and PR workflow.
+2. On commit or `/metrics`, the tool first tries the normal Claude-local data sources.
+3. If Claude session data is unavailable, it looks for a matching Copilot CLI session under `~/.copilot/session-state/<session-id>/events.jsonl`.
+4. It matches sessions by repo path, branch, and recency, then extracts:
+   - prompt count
+   - AI vs human active time
+   - tool usage
+   - skill usage
+   - agent usage
+   - dominant model / known token counts
+5. That normalized session data is attached to the git note so PR metrics can still be rebuilt later from durable note metadata.
+
+Optional prompt markers:
+
+- If your Copilot CLI workflow includes prompts beginning with `start work` and `create pr`, those are used as a tighter timing window.
+- If not, the tool falls back to the broader repo/branch session window automatically.
+
+Limitations:
+
+- Copilot CLI local session-state currently does **not** expose enough durable billing data to estimate cost reliably, so cost is rendered as **unavailable**.
+- Copilot CLI does not provide Claude-style file checkpoints, so attribution may fall back to commit/diff heuristics when no checkpoints exist.
 
 ### Checking raw attribution data
 
@@ -528,7 +599,7 @@ When no destination is configured, the workflow runs in **dry-run mode** — it
 
 Set secrets at the org level so they apply to all repos that use this tool. Multiple export destinations can be active simultaneously (e.g. both `OTEL_EXPORTER_OTLP_ENDPOINT` and `METRICS_WEBHOOK_URL`).
 
-**Model pricing (org variables — update when Anthropic changes pricing):**
+**Model pricing (Claude-only org variables — update when Anthropic changes pricing):**
 
 | Variable | Default | Description |
 |----------|---------|-------------|
@@ -541,7 +612,7 @@ Set secrets at the org level so they apply to all repos that use this tool. Mult
 | `CLAUDE_PRICE_CACHE_READ_MULT` | `0.1` | Fraction of input price for cache reads |
 | `CLAUDE_PRICE_CACHE_WRITE_MULT` | `1.25` | Fraction of input price for cache writes |
 
-Unrecognized model names (new Claude releases) fall back to Opus pricing. Set these as org-level **variables** (not secrets) — they're not sensitive.
+These pricing variables apply to **Claude token-based cost estimation only**. Copilot metrics currently report cost as **unavailable** unless a future durable billing/token source is added. Unrecognized Claude model names fall back to Opus pricing. Set these as org-level **variables** (not secrets) — they're not sensitive.
 
 
 ---
@@ -562,7 +633,13 @@ When generating PR metrics, branch commits that have no git note are checked for
 | `Co-authored-by:` trailer | `Co-authored-by: Claude <...>` |
 | `Co-authored-by:` trailer | `Co-authored-by: GitHub Copilot <...>` |
 
-If detected, all non-blank committed lines are counted as AI in the metrics output. No git note is written — this is a metrics-time synthesis only.
+If detected, all non-blank committed lines are counted as AI in the metrics output and the assistant runtime is labeled as Copilot or Claude when that can be inferred. No git note is written — this is a metrics-time synthesis only.
+
+This hosted/bot path is intentionally conservative:
+
+- attribution: **heuristic but durable enough for PR metrics**
+- assistant runtime: **best effort**
+- time/cost: **not available** from current hosted signals
 
 **Not detectable:** Copilot "Commit suggestion" (the button on PR review comments). Those commits are authored as the human who clicked the button — there is no metadata distinguishing them from a human edit. They will count as HUMAN.
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "claude-attribution",
-	"version": "1.8.0",
-	"description": "AI code attribution tracking for Claude Code sessions — checkpoint-based line diff approach",
+	"version": "1.9.4",
+	"description": "AI code attribution tracking for Claude Code and GitHub Copilot sessions",
 	"type": "module",
 	"bin": {
 		"claude-attribution": "bin/claude-attribution"

package/src/__tests__/claude-projects.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { createTempContext } from "./integration-helpers.ts";
+import {
+	claudeProjectKey,
+	resolveClaudeProjectDir,
+} from "../metrics/claude-projects.ts";
+
+describe("claude project directory resolution", () => {
+	test("sanitizes dotted repo paths the same way Claude transcripts do", () => {
+		expect(claudeProjectKey("/Users/alice.smith/Code/my-repo")).toBe(
+			"-Users-alice-smith-Code-my-repo",
+		);
+	});
+
+	test("resolves sanitized transcript directories", async () => {
+		const ctx = await createTempContext("claude-projects");
+		try {
+			const repo = "/Users/alice.smith/Code/my-repo";
+			const projectsRoot = join(ctx.home, ".claude", "projects");
+			const dir = join(projectsRoot, "-Users-alice-smith-Code-my-repo");
+			await mkdir(dir, { recursive: true });
+			expect(await resolveClaudeProjectDir(repo, projectsRoot)).toBe(dir);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("falls back to legacy slash-only keys for backward compatibility", async () => {
+		const ctx = await createTempContext("claude-projects-legacy");
+		try {
+			const repo = "/Users/alice/Code/my-repo";
+			const projectsRoot = join(ctx.home, ".claude", "projects");
+			const dir = join(projectsRoot, "-Users-alice-Code-my-repo");
+			await mkdir(dir, { recursive: true });
+			expect(await resolveClaudeProjectDir(repo, projectsRoot)).toBe(dir);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+});

package/src/__tests__/copilot-session.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import { parseCopilotSession, resolveCopilotSessionId } from "../metrics/copilot-session.ts";
+import { createTempContext, writeCopilotSession } from "./integration-helpers.ts";
+
+describe("copilot-session", () => {
+	test("parses local Copilot session metrics", async () => {
+		const ctx = await createTempContext("copilot-session");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			const sessionId = "copilot-session-1";
+			await writeCopilotSession(ctx.home, sessionId, [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: {
+							cwd: ctx.repo,
+							gitRoot: ctx.repo,
+							branch: "feature/copilot",
+						},
+					},
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: { content: "Investigate parser" },
+				},
+				{
+					type: "tool.execution_start",
+					timestamp: "2026-04-01T10:00:05.000Z",
+					data: { toolName: "web_search" },
+				},
+				{
+					type: "tool.execution_start",
+					timestamp: "2026-04-01T10:00:06.000Z",
+					data: { toolName: "skill", arguments: { skill: "pr" } },
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { outputTokens: 320 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:01:00.000Z",
+				},
+				{
+					type: "subagent.started",
+					timestamp: "2026-04-01T10:01:10.000Z",
+					data: { agentName: "ux-reviewer" },
+				},
+				{
+					type: "subagent.completed",
+					timestamp: "2026-04-01T10:01:30.000Z",
+					data: { model: "gpt-5-mini", totalTokens: 80 },
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:02:00.000Z",
+					data: { content: "Create the PR" },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:03:00.000Z",
+				},
+			]);
+
+			const parsed = await parseCopilotSession(sessionId, ctx.repo);
+
+			expect(parsed).not.toBeNull();
+			expect(parsed?.provider).toBe("copilot");
+			expect(parsed?.humanPromptCount).toBe(2);
+			expect(parsed?.toolCounts).toEqual({ web_search: 1, skill: 1 });
+			expect(parsed?.skillNames).toEqual(["pr"]);
+			expect(parsed?.agentCounts).toEqual({ "ux-reviewer": 1 });
+			expect(parsed?.byModel).toEqual([
+				{
+					modelShort: "Unknown",
+					modelFull: "gpt-5-mini",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 80,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+				{
+					modelShort: "Unknown",
+					modelFull: "gpt-5.4",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 320,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+			]);
+			expect(parsed?.activeMinutes).toBe(3);
+			expect(parsed?.aiMinutes).toBe(2);
+			expect(parsed?.humanMinutes).toBe(1);
+			expect(parsed?.costMode).toBe("unavailable");
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+
+	test("resolves the best matching session for a repo and branch", async () => {
+		const ctx = await createTempContext("copilot-session-resolve");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			await writeCopilotSession(ctx.home, "older-session", [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T09:00:00.000Z",
+					data: { context: { gitRoot: ctx.repo, branch: "main" } },
+				},
+			]);
+			await writeCopilotSession(ctx.home, "best-session", [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: { gitRoot: ctx.repo, cwd: ctx.repo, branch: "feature/copilot" },
+					},
+				},
+			]);
+
+			const resolved = await resolveCopilotSessionId(ctx.repo, "feature/copilot");
+			expect(resolved).toBe("best-session");
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+});

package/src/__tests__/differ.test.ts

@@ -75,8 +75,8 @@ describe("attributeLines — basic classification", () => {
 	});
 
 	test("line not in after, committed file longer than after-snapshot → HUMAN", () => {
-		// When the committed file has more lines than the after-snapshot, the
-		// positional MIXED check doesn't fire for out-of-bounds positions.
+		// Insertions are treated as HUMAN unless we can anchor them as one-for-one
+		// replacements of Claude-authored lines.
 		const before: string[] = [];
 		const after = ["const x = 1;"]; // only 1 line
 		// Human committed 2 lines — position 1 is beyond after-snapshot length
@@ -86,6 +86,18 @@ describe("attributeLines — basic classification", () => {
 		expect(attribution[1]).toBe("HUMAN"); // position 1 is beyond after-snapshot — no MIXED
 	});
 
+	test("human insertion above AI lines does not create false MIXED classifications", () => {
+		const before: string[] = [];
+		const after = ["const a = 1;", "const b = 2;"];
+		const committed = ["// intro", "const a = 1;", "const b = 2;"];
+		const { attribution, stats } = attributeLines(before, after, committed);
+		expect(attribution).toEqual(["HUMAN", "AI", "AI"]);
+		expect(stats.ai).toBe(2);
+		expect(stats.human).toBe(1);
+		expect(stats.mixed).toBe(0);
+		expect(stats.pctAi).toBe(67);
+	});
+
 	test("empty lines always → HUMAN regardless of snapshot", () => {
 		const before: string[] = [];
 		const after = ["", "const x = 1;", ""];

package/src/__tests__/git-notes.test.ts

@@ -137,4 +137,32 @@ timestamp: new Date().toISOString(),
 }),
 ).toBe(false);
 });
+
+test("buildAllAiResult tags hosted Copilot commits with assistant runtime", async () => {
+const ctx = await createTempContext("claude-attribution-copilot-bot");
+try {
+await initGitRepo(ctx.repo);
+await runCommand("git", ["config", "user.name", "copilot[bot]"], { cwd: ctx.repo });
+await runCommand(
+"git",
+["config", "user.email", "000000+copilot[bot]@users.noreply.github.com"],
+{ cwd: ctx.repo },
+);
+await writeFile(join(ctx.repo, "agent.ts"), "export const generated = true;\n");
+await commitAll(
+ctx.repo,
+"feat: add hosted change\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>",
+);
+const sha = await currentSha(ctx.repo);
+
+const result = await buildAllAiResult(ctx.repo, sha);
+
+expect(result.assistantRuntime).toEqual({
+vendor: "copilot",
+client: "GitHub Copilot",
+});
+} finally {
+await ctx.cleanup();
+}
+});
 });

package/src/__tests__/installed-repos.test.ts

@@ -34,8 +34,9 @@ describe("installed repo registry", () => {
 				"1.7.0",
 			);
 
-			await unregisterInstalledRepo(repo2, ctx.home);
+			expect(await unregisterInstalledRepo(repo2, ctx.home)).toBe(true);
 			expect(await readInstalledRepoRegistry(ctx.home)).toHaveLength(1);
+			expect(await unregisterInstalledRepo(repo2, ctx.home)).toBe(false);
 
 			await writeInstalledRepoRegistry(
 				[

package/src/__tests__/integration-helpers.ts

@@ -10,6 +10,7 @@ import {
 import { tmpdir } from "os";
 import { dirname, join, resolve } from "path";
 import { promisify } from "util";
+import { claudeProjectKey } from "../metrics/claude-projects.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -113,7 +114,7 @@ export async function writeJsonl(
 }
 
 export function transcriptDirFor(home: string, repo: string): string {
-	return join(home, ".claude", "projects", repo.replace(/\//g, "-"));
+	return join(home, ".claude", "projects", claudeProjectKey(repo));
 }
 
 export async function writeTranscript(
@@ -127,6 +128,16 @@ export async function writeTranscript(
 	await writeJsonl(join(dir, `${sessionId}.jsonl`), entries);
 }
 
+export async function writeCopilotSession(
+	home: string,
+	sessionId: string,
+	entries: unknown[],
+): Promise<void> {
+	const dir = join(home, ".copilot", "session-state", sessionId);
+	await mkdir(dir, { recursive: true });
+	await writeJsonl(join(dir, "events.jsonl"), entries);
+}
+
 export async function readJson(path: string): Promise<unknown> {
 	return JSON.parse(await readFile(path, "utf8"));
 }