bikky 0.4.0 → 0.4.2

package/dist/daemon/extraction.js

@@ -1,15 +1,15 @@
 /**
- * Events-based memory extraction — reads Copilot CLI events.jsonl transcripts,
+ * Events-based memory extraction — reads supported coding-agent transcripts,
  * extracts facts via LLM, and stores them in Qdrant with source: "system".
  *
  * Uses a JSON file for extraction state (high-water byte offsets) instead of SQLite.
- * Active session detection scans ~/.copilot/session-state/ for lock files.
+ * Copilot session detection uses lock files. Claude Code detection uses
+ * top-level JSONL transcripts under ~/.claude/projects.
  */
-import { readFile, readdir, stat } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { loadConfig, STATE_DIR, EXTRACTION_HEALTH_PATH } from "../config.js";
+import { STATE_DIR, EXTRACTION_HEALTH_PATH } from "../config.js";
 import * as qdrant from "./qdrant.js";
 import { chatCompletion } from "../llm/index.js";
 import { detectContradiction } from "./consolidation.js";
@@ -20,6 +20,7 @@ import { shouldSummarizeEvents, updateSessionSummary } from "./session-summary.j
 import { redactStorageText } from "../privacy/redaction.js";
 import { compareSubtype, hasTypedToken, verifyGrounding, verifyVolatilityCoherence } from "./extraction-rules.js";
 import { resolveActorIdentity } from "../provenance/actor.js";
+import { discoverClaudeTranscriptMappings, discoverCopilotTranscriptMappings, extractionStateKey, readNewTranscriptEvents, transcriptLabel, } from "./transcript-sources.js";
 // ── Module state ─────────────────────────────────────────────────────────────
 let logFn = (() => { });
 let lastTickAt = 0;
@@ -27,11 +28,6 @@ export const setLogger = (fn) => {
     logFn = fn;
 };
 // ── Constants ────────────────────────────────────────────────────────────────
-const EXTRACTABLE_TYPES = new Set([
-    "user.message",
-    "assistant.message",
-    "session.compaction_complete",
-]);
 export const DEFAULT_EXTRACTION_PROMPT = `You are Bikky's memory extraction agent for open-source coding agents. Extract durable, reusable facts that help a future agent continue work without rereading the whole transcript.
 
 ## Core rule
@@ -123,50 +119,6 @@ const upsertExtractionState = (state) => {
     states[state.session_id] = state;
     saveExtractionStates(states);
 };
-/**
- * Scan lock files to build PID → Copilot UUID mapping.
- * Copilot CLI writes `inuse.<pid>.lock` in each session directory.
- */
-const resolveLockFiles = async () => {
-    const cfg = loadConfig();
-    const copilotStateDir = cfg.watchers.copilot.path;
-    const mappings = [];
-    try {
-        const sessionDirs = await readdir(copilotStateDir, { withFileTypes: true });
-        for (const sessionDir of sessionDirs) {
-            if (!sessionDir.isDirectory())
-                continue;
-            const uuid = sessionDir.name;
-            const sessionPath = join(copilotStateDir, uuid);
-            const entries = await readdir(sessionPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isFile())
-                    continue;
-                const lockFile = entry.name; // inuse.12345.lock
-                const pidMatch = lockFile.match(/^inuse\.(\d+)\.lock$/);
-                if (!pidMatch || !uuid)
-                    continue;
-                const pid = parseInt(pidMatch[1], 10);
-                const eventsPath = join(copilotStateDir, uuid, "events.jsonl");
-                // Verify events.jsonl exists
-                try {
-                    await stat(eventsPath);
-                    mappings.push({ pid, uuid, eventsPath });
-                }
-                catch {
-                    // No events.jsonl — skip
-                }
-            }
-        }
-    }
-    catch (e) {
-        logFn("WARN", `Lock file scan failed: ${e.message}`);
-    }
-    return mappings;
-};
-/**
- * Check if a process is still running.
- */
 const isProcessAlive = (pid) => {
     try {
         process.kill(pid, 0);
@@ -176,59 +128,6 @@ const isProcessAlive = (pid) => {
         return false;
     }
 };
-/**
- * Read new events from events.jsonl starting at the given byte offset.
- * Returns parsed extractable events and the new byte offset.
- */
-const readNewEvents = async (eventsPath, byteOffset) => {
-    const fileStat = await stat(eventsPath);
-    if (fileStat.size <= byteOffset) {
-        return { events: [], newOffset: byteOffset, totalLines: 0 };
-    }
-    // Read from byte offset to end of file
-    const buf = await readFile(eventsPath);
-    const newContent = buf.subarray(byteOffset).toString("utf-8");
-    const events = [];
-    let totalLines = 0;
-    for (const line of newContent.split("\n")) {
-        if (!line.trim())
-            continue;
-        totalLines++;
-        try {
-            const obj = JSON.parse(line);
-            if (!EXTRACTABLE_TYPES.has(obj.type))
-                continue;
-            const data = obj.data || {};
-            let content = "";
-            if (obj.type === "user.message") {
-                content = data.content || "";
-            }
-            else if (obj.type === "assistant.message") {
-                const parts = [];
-                if (data.content)
-                    parts.push(data.content);
-                if (data.reasoningText)
-                    parts.push(data.reasoningText);
-                // Skip reasoningOpaque — encrypted noise
-                content = parts.join("\n");
-            }
-            else if (obj.type === "session.compaction_complete") {
-                content = data.summaryContent || "";
-            }
-            if (content.length > 0) {
-                events.push({
-                    type: obj.type,
-                    content,
-                    timestamp: obj.timestamp || new Date().toISOString(),
-                });
-            }
-        }
-        catch {
-            // Malformed line — skip
-        }
-    }
-    return { events, newOffset: fileStat.size, totalLines };
-};
 /**
  * Strip tool-call narration and boilerplate from assistant messages.
  * Keeps substantive content — decisions, explanations, findings.
@@ -504,7 +403,7 @@ const contentHash = (text) => createHash("sha256").update(text).digest("hex");
  * Dedup-check and store extracted facts in Qdrant.
  * Returns count of facts actually inserted.
  */
-const storeFacts = async (facts, sessionId, config) => {
+const storeFacts = async (facts, sessionId, config, source) => {
     if (!qdrant.isReady()) {
         logFn("WARN", "Extraction: Qdrant not ready, skipping store");
         return 0;
@@ -514,6 +413,8 @@ const storeFacts = async (facts, sessionId, config) => {
         capture_policy_version: CAPTURE_POLICY_VERSION,
         extracted_by_prompt: `${EXTRACTION_PROMPT_DESCRIPTOR.id}@${EXTRACTION_PROMPT_DESCRIPTOR.version}`,
     };
+    if (source)
+        baseMeta.extraction_source = source;
     const actor = resolveActorIdentity({ config });
     if (actor.actor_label)
         baseMeta.actor_label = actor.actor_label;
@@ -729,20 +630,38 @@ export const tick = async (config) => {
     lastTickAt = now;
     const minEvents = config.daemon.extract_min_events || CAPTURE_TRIGGERS.factExtraction.minEvents;
     try {
-        // Extract from ALL active Copilot sessions with events.jsonl
-        const lockMappings = await resolveLockFiles();
-        const aliveMappings = lockMappings.filter(m => isProcessAlive(m.pid));
-        logFn("INFO", `Extraction tick: ${aliveMappings.length} active copilot session(s) with events.jsonl`);
-        writeExtractionHealth(aliveMappings.length, config);
-        for (const mapping of aliveMappings) {
-            await extractForUuid(mapping, minEvents, config);
+        const copilotMappings = await discoverCopilotMappings(config);
+        const claudeMappings = await discoverClaudeMappings(config);
+        const mappings = [...copilotMappings, ...claudeMappings];
+        logFn("INFO", `Extraction tick: ${copilotMappings.length} active copilot session(s), ${claudeMappings.length} claude transcript(s)`);
+        writeExtractionHealth({ copilot: copilotMappings.length, claude: claudeMappings.length }, config);
+        for (const mapping of mappings) {
+            await extractForMapping(mapping, minEvents, config);
         }
     }
     catch (e) {
         logFn("ERROR", `Extraction tick failed: ${e.message}`);
     }
 };
-function writeExtractionHealth(activeCount, config) {
+const discoverCopilotMappings = async (config) => {
+    try {
+        return await discoverCopilotTranscriptMappings(config, isProcessAlive);
+    }
+    catch (e) {
+        logFn("WARN", `Copilot transcript scan failed: ${e.message}`);
+        return [];
+    }
+};
+const discoverClaudeMappings = async (config) => {
+    try {
+        return await discoverClaudeTranscriptMappings(config);
+    }
+    catch (e) {
+        logFn("WARN", `Claude transcript scan failed: ${e.message}`);
+        return [];
+    }
+};
+function writeExtractionHealth(activeCounts, config) {
     try {
         let existing = {};
         if (existsSync(EXTRACTION_HEALTH_PATH)) {
@@ -752,11 +671,33 @@ function writeExtractionHealth(activeCount, config) {
             catch { /* ignore */ }
         }
         const now = new Date().toISOString();
+        const activeCount = activeCounts.copilot + activeCounts.claude;
+        const existingSources = existing.sources ?? {};
+        const copilotLastActive = activeCounts.copilot > 0
+            ? now
+            : (existingSources.copilot?.last_active_session_at ?? existing.last_active_session_at ?? null);
+        const claudeLastActive = activeCounts.claude > 0
+            ? now
+            : (existingSources.claude?.last_active_session_at ?? null);
         const health = {
             last_tick_at: now,
             last_active_session_at: activeCount > 0 ? now : (existing.last_active_session_at ?? null),
             active_session_count: activeCount,
             watcher_path: config.watchers.copilot.path,
+            sources: {
+                copilot: {
+                    enabled: config.watchers.copilot.enabled,
+                    watcher_path: config.watchers.copilot.path,
+                    active_session_count: activeCounts.copilot,
+                    last_active_session_at: copilotLastActive,
+                },
+                claude: {
+                    enabled: config.watchers.claude.enabled,
+                    watcher_path: config.watchers.claude.path,
+                    active_session_count: activeCounts.claude,
+                    last_active_session_at: claudeLastActive,
+                },
+            },
         };
         mkdirSync(STATE_DIR, { recursive: true });
         writeFileSync(EXTRACTION_HEALTH_PATH, JSON.stringify(health, null, 2) + "\n");
@@ -765,32 +706,37 @@ function writeExtractionHealth(activeCount, config) {
         logFn("DEBUG", `Failed to write extraction health: ${e.message}`);
     }
 }
-/**
- * Extract facts for a single Copilot session identified by UUID.
- * Uses UUID as the extraction_state key.
- * Automatically chunks large transcripts into multiple LLM calls.
- */
-const extractForUuid = async (mapping, minEvents, config) => {
-    const { uuid, eventsPath } = mapping;
-    // Use UUID as session_id in extraction_state (prefix with "uuid:" to avoid collisions)
-    const stateKey = `uuid:${uuid}`;
+const extractForMapping = async (mapping, minEvents, config) => {
+    const { uuid, eventsPath, source } = mapping;
+    const stateKey = extractionStateKey(mapping);
+    const label = transcriptLabel(mapping);
     let state = getExtractionState(stateKey);
     if (!state) {
         state = {
             session_id: stateKey,
-            copilot_uuid: uuid,
+            source,
+            ...(source === "copilot" ? { copilot_uuid: uuid } : { claude_session_id: uuid }),
             events_path: eventsPath,
             byte_offset: 0,
             last_extracted_at: null,
             event_count: 0,
         };
     }
+    state.source = source;
+    if (source === "copilot") {
+        state.copilot_uuid = uuid;
+    }
+    else {
+        state.claude_session_id = uuid;
+    }
+    state.events_path = eventsPath;
     // Read new events
-    const { events, newOffset, totalLines } = await readNewEvents(eventsPath, state.byte_offset);
+    const { events, newOffset, totalLines } = await readNewTranscriptEvents(eventsPath, state.byte_offset, source);
     const shouldSummarize = shouldSummarizeEvents(events, minEvents);
     if (events.length < minEvents && !shouldSummarize) {
-        // Still update offset to avoid re-scanning non-extractable events
-        if (newOffset > state.byte_offset) {
+        // Still advance past pure noise, but keep below-threshold conversation
+        // events buffered until enough context accumulates for extraction.
+        if (events.length === 0 && newOffset > state.byte_offset) {
             state.byte_offset = newOffset;
             state.event_count += totalLines;
             upsertExtractionState(state);
@@ -802,27 +748,33 @@ const extractForUuid = async (mapping, minEvents, config) => {
     let totalFacts = 0;
     for (let i = 0; i < chunks.length; i++) {
         const transcript = buildTranscript(chunks[i]);
-        logFn("DEBUG", `Extraction: UUID ${uuid.slice(0, 8)} — chunk ${i + 1}/${chunks.length}, ${chunks[i].length} events, ${transcript.length} chars`);
+        logFn("DEBUG", `Extraction: ${label} — chunk ${i + 1}/${chunks.length}, ${chunks[i].length} events, ${transcript.length} chars`);
         if (events.length >= minEvents) {
             const facts = await extractFacts(transcript, stateKey, config);
             if (facts.length > 0) {
-                const stored = await storeFacts(facts, stateKey, config);
+                const stored = await storeFacts(facts, stateKey, config, source);
                 totalFacts += stored;
             }
         }
         await updateSummaryForTranscript(stateKey, transcript, chunks[i].length, config);
     }
     if (totalFacts > 0) {
-        logFn("INFO", `Extraction: UUID ${uuid.slice(0, 8)} — ${totalFacts} facts stored (${events.length} events, ${chunks.length} chunk(s))`);
+        logFn("INFO", `Extraction: ${label} — ${totalFacts} facts stored (${events.length} events, ${chunks.length} chunk(s))`);
     }
     else {
-        logFn("DEBUG", `Extraction: UUID ${uuid.slice(0, 8)} — ${events.length} events but 0 facts extracted`);
+        logFn("DEBUG", `Extraction: ${label} — ${events.length} events but 0 facts extracted`);
     }
     // Update high-water mark
     state.byte_offset = newOffset;
     state.event_count += totalLines;
     state.last_extracted_at = new Date().toISOString();
-    state.copilot_uuid = uuid;
+    state.source = source;
+    if (source === "copilot") {
+        state.copilot_uuid = uuid;
+    }
+    else {
+        state.claude_session_id = uuid;
+    }
     state.events_path = eventsPath;
     upsertExtractionState(state);
     return totalFacts;

package/dist/daemon/transcript-sources.d.ts

@@ -0,0 +1,26 @@
+import type { BikkyConfig } from "../config.js";
+export type TranscriptSource = "copilot" | "claude";
+export interface TranscriptMapping {
+    source: TranscriptSource;
+    uuid: string;
+    eventsPath: string;
+    active: boolean;
+    pid?: number;
+}
+export interface ParsedEvent {
+    type: string;
+    content: string;
+    timestamp: string;
+}
+export declare const extractionStateKey: (mapping: Pick<TranscriptMapping, "source" | "uuid">) => string;
+export declare const transcriptLabel: (mapping: Pick<TranscriptMapping, "source" | "uuid">) => string;
+export declare const discoverCopilotTranscriptMappings: (config: BikkyConfig, isProcessAlive: (pid: number) => boolean) => Promise<TranscriptMapping[]>;
+export declare const discoverClaudeTranscriptMappings: (config: BikkyConfig) => Promise<TranscriptMapping[]>;
+export declare const parseCopilotTranscriptLine: (line: string) => ParsedEvent | null;
+export declare const parseClaudeTranscriptLine: (line: string) => ParsedEvent | null;
+export declare const readNewTranscriptEvents: (eventsPath: string, byteOffset: number, source: TranscriptSource) => Promise<{
+    events: ParsedEvent[];
+    newOffset: number;
+    totalLines: number;
+}>;
+//# sourceMappingURL=transcript-sources.d.ts.map

package/dist/daemon/transcript-sources.js

@@ -0,0 +1,193 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+const COPILOT_EXTRACTABLE_TYPES = new Set([
+    "user.message",
+    "assistant.message",
+    "session.compaction_complete",
+]);
+const isNotFoundError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+const readDirIfExists = async (dir) => {
+    try {
+        return await readdir(dir, { withFileTypes: true });
+    }
+    catch (e) {
+        if (isNotFoundError(e))
+            return [];
+        throw e;
+    }
+};
+export const extractionStateKey = (mapping) => mapping.source === "copilot" ? `uuid:${mapping.uuid}` : `claude:${mapping.uuid}`;
+export const transcriptLabel = (mapping) => `${mapping.source}:${mapping.uuid.slice(0, 8)}`;
+export const discoverCopilotTranscriptMappings = async (config, isProcessAlive) => {
+    if (!config.watchers.copilot.enabled)
+        return [];
+    const copilotStateDir = config.watchers.copilot.path;
+    const mappings = [];
+    const sessionDirs = await readDirIfExists(copilotStateDir);
+    for (const sessionDir of sessionDirs) {
+        if (!sessionDir.isDirectory())
+            continue;
+        const uuid = sessionDir.name;
+        const sessionPath = join(copilotStateDir, uuid);
+        const entries = await readDirIfExists(sessionPath);
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const pidMatch = entry.name.match(/^inuse\.(\d+)\.lock$/);
+            if (!pidMatch || !uuid)
+                continue;
+            const pid = parseInt(pidMatch[1], 10);
+            if (!isProcessAlive(pid))
+                continue;
+            const eventsPath = join(copilotStateDir, uuid, "events.jsonl");
+            try {
+                await stat(eventsPath);
+            }
+            catch (e) {
+                if (isNotFoundError(e))
+                    continue;
+                throw e;
+            }
+            mappings.push({ source: "copilot", pid, uuid, eventsPath, active: true });
+        }
+    }
+    return mappings;
+};
+export const discoverClaudeTranscriptMappings = async (config) => {
+    if (!config.watchers.claude.enabled)
+        return [];
+    const baseDir = config.watchers.claude.path;
+    const mappings = [];
+    const entries = await readDirIfExists(baseDir);
+    for (const entry of entries) {
+        const entryPath = join(baseDir, entry.name);
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            const fileStat = await stat(entryPath);
+            mappings.push({
+                source: "claude",
+                uuid: basename(entry.name, ".jsonl"),
+                eventsPath: entryPath,
+                active: true,
+                mtimeMs: fileStat.mtimeMs,
+            });
+            continue;
+        }
+        if (!entry.isDirectory())
+            continue;
+        const projectEntries = await readDirIfExists(entryPath);
+        for (const projectEntry of projectEntries) {
+            if (!projectEntry.isFile() || !projectEntry.name.endsWith(".jsonl"))
+                continue;
+            const eventsPath = join(entryPath, projectEntry.name);
+            const fileStat = await stat(eventsPath);
+            mappings.push({
+                source: "claude",
+                uuid: basename(projectEntry.name, ".jsonl"),
+                eventsPath,
+                active: true,
+                mtimeMs: fileStat.mtimeMs,
+            });
+        }
+    }
+    return mappings
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)
+        .map(({ mtimeMs: _mtimeMs, ...mapping }) => mapping);
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringField = (value) => typeof value === "string" ? value : "";
+const claudeTextContent = (content) => {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === "string") {
+            parts.push(block);
+            continue;
+        }
+        if (!isRecord(block) || block.type !== "text")
+            continue;
+        const text = stringField(block.text);
+        if (text)
+            parts.push(text);
+    }
+    return parts.join("\n");
+};
+export const parseCopilotTranscriptLine = (line) => {
+    const obj = JSON.parse(line);
+    if (!obj.type || !COPILOT_EXTRACTABLE_TYPES.has(obj.type))
+        return null;
+    const data = obj.data || {};
+    let content = "";
+    if (obj.type === "user.message") {
+        content = stringField(data.content);
+    }
+    else if (obj.type === "assistant.message") {
+        const parts = [];
+        const contentText = stringField(data.content);
+        const reasoningText = stringField(data.reasoningText);
+        if (contentText)
+            parts.push(contentText);
+        if (reasoningText)
+            parts.push(reasoningText);
+        content = parts.join("\n");
+    }
+    else if (obj.type === "session.compaction_complete") {
+        content = stringField(data.summaryContent);
+    }
+    if (!content)
+        return null;
+    return {
+        type: obj.type,
+        content,
+        timestamp: obj.timestamp || new Date().toISOString(),
+    };
+};
+export const parseClaudeTranscriptLine = (line) => {
+    const obj = JSON.parse(line);
+    const recordType = obj.type;
+    if (recordType !== "user" && recordType !== "assistant")
+        return null;
+    const message = isRecord(obj.message) ? obj.message : null;
+    if (!message)
+        return null;
+    const role = message.role === "user" || message.role === "assistant" ? message.role : recordType;
+    if (role !== "user" && role !== "assistant")
+        return null;
+    const content = claudeTextContent(message.content).trim();
+    if (!content)
+        return null;
+    return {
+        type: role === "user" ? "user.message" : "assistant.message",
+        content,
+        timestamp: stringField(obj.timestamp) || new Date().toISOString(),
+    };
+};
+export const readNewTranscriptEvents = async (eventsPath, byteOffset, source) => {
+    const fileStat = await stat(eventsPath);
+    if (fileStat.size <= byteOffset) {
+        return { events: [], newOffset: byteOffset, totalLines: 0 };
+    }
+    const buf = await readFile(eventsPath);
+    const newContent = buf.subarray(byteOffset).toString("utf-8");
+    const events = [];
+    let totalLines = 0;
+    for (const line of newContent.split("\n")) {
+        if (!line.trim())
+            continue;
+        totalLines++;
+        try {
+            const event = source === "claude"
+                ? parseClaudeTranscriptLine(line)
+                : parseCopilotTranscriptLine(line);
+            if (event)
+                events.push(event);
+        }
+        catch {
+            // Malformed line — skip it.
+        }
+    }
+    return { events, newOffset: fileStat.size, totalLines };
+};
+//# sourceMappingURL=transcript-sources.js.map

package/dist/daemon/watcher.d.ts

@@ -1,11 +1,12 @@
 /**
- * Copilot session watcher — detects active sessions by scanning
- * ~/.copilot/session-state/ for directories with events.jsonl files.
+ * Session watcher helpers for supported coding-agent transcript directories.
  */
 export interface WatchedSession {
     uuid: string;
     eventsPath: string;
     active: boolean;
+    source?: "copilot" | "claude";
 }
 export declare function discoverSessions(): WatchedSession[];
+export declare function discoverClaudeSessions(): WatchedSession[];
 //# sourceMappingURL=watcher.d.ts.map

package/dist/daemon/watcher.js

@@ -1,6 +1,5 @@
 /**
- * Copilot session watcher — detects active sessions by scanning
- * ~/.copilot/session-state/ for directories with events.jsonl files.
+ * Session watcher helpers for supported coding-agent transcript directories.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -31,8 +30,58 @@ export function discoverSessions() {
             uuid: entry,
             eventsPath,
             active: lockFiles.length > 0,
+            source: "copilot",
         });
     }
     return sessions;
 }
+export function discoverClaudeSessions() {
+    const cfg = loadConfig();
+    if (!cfg.watchers.claude.enabled)
+        return [];
+    const baseDir = cfg.watchers.claude.path;
+    if (!fs.existsSync(baseDir))
+        return [];
+    const sessions = [];
+    for (const entry of fs.readdirSync(baseDir)) {
+        const projectPath = path.join(baseDir, entry);
+        let stat;
+        try {
+            stat = fs.statSync(projectPath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isFile() && entry.endsWith(".jsonl")) {
+            sessions.push({
+                uuid: path.basename(entry, ".jsonl"),
+                eventsPath: projectPath,
+                active: true,
+                source: "claude",
+            });
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        for (const file of fs.readdirSync(projectPath)) {
+            const transcriptPath = path.join(projectPath, file);
+            let transcriptStat;
+            try {
+                transcriptStat = fs.statSync(transcriptPath);
+            }
+            catch {
+                continue;
+            }
+            if (!transcriptStat.isFile() || !file.endsWith(".jsonl"))
+                continue;
+            sessions.push({
+                uuid: path.basename(file, ".jsonl"),
+                eventsPath: transcriptPath,
+                active: true,
+                source: "claude",
+            });
+        }
+    }
+    return sessions;
+}
 //# sourceMappingURL=watcher.js.map

package/dist/install.d.ts

@@ -1,5 +1,13 @@
 /**
  * Write MCP config entries for Copilot and/or Claude Code.
  */
-export declare function writeInstallConfig(): Promise<void>;
+export interface InstallOptions {
+    homeDir?: string;
+    /**
+     * Defaults to `claude`. Set to null to skip the Claude Code CLI and write the
+     * user config file directly.
+     */
+    claudeCommand?: string | null;
+}
+export declare function writeInstallConfig(options?: InstallOptions): Promise<void>;
 //# sourceMappingURL=install.d.ts.map