@jacques-ai/core 0.0.7-alpha.1

package/dist/cache/index.js

@@ -0,0 +1,20 @@
+/**
+ * Cache Module
+ *
+ * Lightweight session indexing without content duplication.
+ * Reads directly from Claude Code JSONL files.
+ */
+export { getDefaultSessionIndex, decodeProjectPath, } from "./types.js";
+// Persistence
+export { getCacheDir, getIndexPath, ensureCacheDir, readSessionIndex, writeSessionIndex, getSessionIndex, invalidateIndex, } from "./persistence.js";
+// Mode detection
+export { detectModeAndPlans } from "./mode-detector.js";
+// Git utilities
+export { detectGitInfo, readGitBranchFromJsonl, readWorktreeRepoRoot, computeBranchDivergence, checkDirtyStatus } from "./git-utils.js";
+// Metadata extraction & index building
+export { extractTitle, extractTimestamps, extractSessionMetadata, extractContinueTitleFromHandoff, listAllProjects, buildSessionIndex, } from "./metadata-extractor.js";
+// Project discovery & query
+export { getProjectGroupKey, discoverProjects, getSessionEntry, getSessionsByProject, getIndexStats, } from "./project-discovery.js";
+// Hidden projects
+export { getHiddenProjects, hideProject, unhideProject, } from "./hidden-projects.js";
+//# sourceMappingURL=index.js.map

package/dist/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH,OAAO,EACL,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,cAAc;AACd,OAAO,EACL,WAAW,EACX,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,iBAAiB;AACjB,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD,gBAAgB;AAChB,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAExI,uCAAuC;AACvC,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,sBAAsB,EACtB,+BAA+B,EAC/B,eAAe,EACf,iBAAiB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,4BAA4B;AAC5B,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAEhC,kBAAkB;AAClB,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,aAAa,GACd,MAAM,sBAAsB,CAAC"}

package/dist/cache/metadata-extractor.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Metadata Extractor
+ *
+ * Extracts session metadata from JSONL files and catalog data.
+ * Builds the session index using a catalog-first strategy.
+ */
+import type { SessionEntry, SessionIndex } from "./types.js";
+/**
+ * Extract "## Current Task" from the most recent handoff created before sessionStartedAt.
+ * Returns "Cont: <task>" or null if no matching handoff found.
+ */
+export declare function extractContinueTitleFromHandoff(projectPath: string, sessionStartedAt: string): Promise<string | null>;
+/**
+ * Extract session title from parsed JSONL entries.
+ * Priority:
+ *   1. Summary entry (Claude's auto-generated title)
+ *   2. First real user message (skips internal command messages)
+ */
+export declare function extractTitle(entries: Array<{
+    type: string;
+    content: {
+        summary?: string;
+        text?: string;
+    };
+}>): string;
+/**
+ * Extract timestamps from entries
+ */
+export declare function extractTimestamps(entries: Array<{
+    timestamp: string;
+}>): {
+    startedAt: string;
+    endedAt: string;
+};
+/**
+ * Extract metadata from a single JSONL file
+ */
+export declare function extractSessionMetadata(jsonlPath: string, projectPath: string, projectSlug: string): Promise<SessionEntry | null>;
+/**
+ * List all project directories in ~/.claude/projects/
+ */
+export declare function listAllProjects(): Promise<Array<{
+    encodedPath: string;
+    projectPath: string;
+    projectSlug: string;
+}>>;
+/**
+ * Scan all sessions and build the index.
+ *
+ * Uses catalog-first loading: reads pre-extracted metadata from .jacques/index.json
+ * for each project, only falling back to JSONL parsing for new/uncataloged sessions.
+ */
+export declare function buildSessionIndex(options?: {
+    /** Progress callback - called for each session scanned */
+    onProgress?: (progress: {
+        phase: "scanning" | "processing";
+        total: number;
+        completed: number;
+        current: string;
+    }) => void;
+}): Promise<SessionIndex>;
+//# sourceMappingURL=metadata-extractor.d.ts.map

package/dist/cache/metadata-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-extractor.d.ts","sourceRoot":"","sources":["../../src/cache/metadata-extractor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAA0C,MAAM,YAAY,CAAC;AAWrG;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC,GAC7E,MAAM,CA6BR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,GACpC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAoBxC;AAkID;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAyG9B;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAC9C,KAAK,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CACzE,CAmCA;AA0MD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAChD,0DAA0D;IAC1D,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QACtB,KAAK,EAAE,UAAU,GAAG,YAAY,CAAC;QACjC,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,KAAK,IAAI,CAAC;CACZ,GAAG,OAAO,CAAC,YAAY,CAAC,CAyExB"}

package/dist/cache/metadata-extractor.js

@@ -0,0 +1,574 @@
+/**
+ * Metadata Extractor
+ *
+ * Extracts session metadata from JSONL files and catalog data.
+ * Builds the session index using a catalog-first strategy.
+ */
+import { promises as fs } from "fs";
+import * as path from "path";
+import { parseJSONL, getEntryStatistics } from "../session/parser.js";
+import { listSubagentFiles, decodeProjectPath } from "../session/detector.js";
+import { readProjectIndex } from "../context/indexer.js";
+import { CLAUDE_PROJECTS_PATH } from "./types.js";
+import { detectGitInfo, readGitBranchFromJsonl } from "./git-utils.js";
+import { detectModeAndPlans } from "./mode-detector.js";
+import { writeSessionIndex } from "./persistence.js";
+import { isContinueSession } from "../session/format-title.js";
+import { isNotFoundError, getErrorMessage } from "../logging/error-utils.js";
+import { createLogger } from "../logging/logger.js";
+const logger = createLogger({ prefix: "[Metadata]" });
+/**
+ * Extract "## Current Task" from the most recent handoff created before sessionStartedAt.
+ * Returns "Cont: <task>" or null if no matching handoff found.
+ */
+export async function extractContinueTitleFromHandoff(projectPath, sessionStartedAt) {
+    const handoffsDir = path.join(projectPath, ".jacques", "handoffs");
+    try {
+        const files = await fs.readdir(handoffsDir);
+        const handoffFiles = files
+            .filter((f) => f.endsWith("-handoff.md"))
+            .sort()
+            .reverse(); // newest first (filenames are ISO-ish timestamps)
+        for (const file of handoffFiles) {
+            // Filename: YYYY-MM-DDTHH-mm-ss-handoff.md → stat for reliable mtime comparison
+            const filePath = path.join(handoffsDir, file);
+            const stat = await fs.stat(filePath);
+            if (stat.mtime.getTime() > new Date(sessionStartedAt).getTime()) {
+                continue; // handoff created after session started — skip
+            }
+            const content = await fs.readFile(filePath, "utf-8");
+            const taskMatch = content.match(/## Current Task\n+(.+?)(?=\n## |\n*$)/s);
+            if (taskMatch) {
+                const task = taskMatch[1].trim();
+                const firstLine = task.split("\n")[0].trim();
+                if (firstLine) {
+                    return `Cont: ${firstLine}`;
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (!isNotFoundError(err)) {
+            logger.warn("Failed to read handoffs for continue title:", getErrorMessage(err));
+        }
+    }
+    return null;
+}
+/**
+ * Extract session title from parsed JSONL entries.
+ * Priority:
+ *   1. Summary entry (Claude's auto-generated title)
+ *   2. First real user message (skips internal command messages)
+ */
+export function extractTitle(entries) {
+    // Try summary first
+    const summaryEntry = entries.find((e) => e.type === "summary" && e.content.summary);
+    if (summaryEntry?.content.summary) {
+        return summaryEntry.content.summary;
+    }
+    // Fallback to first real user message (skip internal command messages)
+    const userMessage = entries.find((e) => {
+        if (e.type !== "user_message" || !e.content.text)
+            return false;
+        const text = e.content.text.trim();
+        // Skip internal Claude Code messages
+        if (text.startsWith("<local-command"))
+            return false;
+        if (text.startsWith("<command-"))
+            return false;
+        if (text.length === 0)
+            return false;
+        return true;
+    });
+    if (userMessage?.content.text) {
+        // Truncate long messages
+        const text = userMessage.content.text.trim();
+        if (text.length > 100) {
+            return text.slice(0, 97) + "...";
+        }
+        return text;
+    }
+    return "Untitled Session";
+}
+/**
+ * Extract timestamps from entries
+ */
+export function extractTimestamps(entries) {
+    if (entries.length === 0) {
+        const now = new Date().toISOString();
+        return { startedAt: now, endedAt: now };
+    }
+    // Find earliest and latest timestamps
+    let startedAt = entries[0].timestamp;
+    let endedAt = entries[0].timestamp;
+    for (const entry of entries) {
+        if (entry.timestamp < startedAt) {
+            startedAt = entry.timestamp;
+        }
+        if (entry.timestamp > endedAt) {
+            endedAt = entry.timestamp;
+        }
+    }
+    return { startedAt, endedAt };
+}
+/**
+ * Extract explore agents and web searches from entries.
+ * For explore agents, computes token cost from their subagent JSONL files.
+ */
+async function extractAgentsAndSearches(entries, subagentFiles) {
+    const exploreAgents = [];
+    const webSearches = [];
+    const seenAgentIds = new Set();
+    const seenQueries = new Set();
+    // Build a map of agentId -> subagent file for quick lookup
+    const subagentFileMap = new Map();
+    for (const f of subagentFiles) {
+        subagentFileMap.set(f.agentId, f);
+    }
+    for (const entry of entries) {
+        // Extract explore agents from agent_progress entries
+        if (entry.type === 'agent_progress' && entry.content.agentType === 'Explore') {
+            const agentId = entry.content.agentId;
+            if (agentId && !seenAgentIds.has(agentId)) {
+                seenAgentIds.add(agentId);
+                exploreAgents.push({
+                    id: agentId,
+                    description: entry.content.agentDescription || 'Explore codebase',
+                    timestamp: entry.timestamp,
+                });
+            }
+        }
+        // Extract web searches from web_search entries with results
+        if (entry.type === 'web_search' && entry.content.searchType === 'results') {
+            const query = entry.content.searchQuery;
+            if (query && !seenQueries.has(query)) {
+                seenQueries.add(query);
+                webSearches.push({
+                    query,
+                    resultCount: entry.content.searchResultCount || 0,
+                    timestamp: entry.timestamp,
+                });
+            }
+        }
+    }
+    // Compute token costs for explore agents from their subagent JSONL files
+    for (const agent of exploreAgents) {
+        const subagentFile = subagentFileMap.get(agent.id);
+        if (subagentFile) {
+            try {
+                const subEntries = await parseJSONL(subagentFile.filePath);
+                if (subEntries.length > 0) {
+                    const subStats = getEntryStatistics(subEntries);
+                    // Total cost = last turn's context window size + estimated output
+                    const inputCost = subStats.lastInputTokens + subStats.lastCacheRead;
+                    const outputCost = subStats.totalOutputTokensEstimated;
+                    agent.tokenCost = inputCost + outputCost;
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to parse subagent ${agent.id}:`, getErrorMessage(err));
+            }
+        }
+    }
+    return { exploreAgents, webSearches };
+}
+/**
+ * Convert a catalog SubagentEntry (type=exploration) to an ExploreAgentRef.
+ */
+function catalogSubagentToExploreRef(entry) {
+    return {
+        id: entry.id,
+        description: entry.title,
+        timestamp: entry.timestamp,
+        tokenCost: entry.tokenCost,
+    };
+}
+/**
+ * Convert a catalog SubagentEntry (type=search) to a WebSearchRef.
+ */
+function catalogSubagentToSearchRef(entry) {
+    return {
+        query: entry.title,
+        resultCount: entry.resultCount || 0,
+        timestamp: entry.timestamp,
+    };
+}
+/**
+ * Convert a catalog PlanEntry to a partial PlanRef.
+ * messageIndex is set to 0 since catalog doesn't track this.
+ */
+function catalogPlanToPlanRef(plan) {
+    return {
+        title: plan.title,
+        source: "embedded",
+        messageIndex: 0,
+        catalogId: plan.id,
+    };
+}
+/**
+ * Read the session manifest JSON from .jacques/sessions/{id}.json.
+ * Returns null if file doesn't exist or is unreadable.
+ */
+async function readSessionManifest(projectPath, sessionId) {
+    try {
+        const manifestPath = path.join(projectPath, ".jacques", "sessions", `${sessionId}.json`);
+        const content = await fs.readFile(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (err) {
+        if (!isNotFoundError(err)) {
+            logger.warn(`Failed to read session manifest ${sessionId}:`, getErrorMessage(err));
+        }
+        return null;
+    }
+}
+/**
+ * Extract metadata from a single JSONL file
+ */
+export async function extractSessionMetadata(jsonlPath, projectPath, projectSlug) {
+    try {
+        // Get file stats
+        const stats = await fs.stat(jsonlPath);
+        const sessionId = path.basename(jsonlPath, ".jsonl");
+        // Parse JSONL to get metadata
+        const entries = await parseJSONL(jsonlPath);
+        if (entries.length === 0) {
+            return null;
+        }
+        // Get statistics
+        const entryStats = getEntryStatistics(entries);
+        // Get timestamps
+        const { startedAt, endedAt } = extractTimestamps(entries);
+        // Get title — resolve continue sessions from handoff data
+        let title = extractTitle(entries);
+        if (isContinueSession(title)) {
+            const continueTitle = await extractContinueTitleFromHandoff(projectPath, startedAt);
+            if (continueTitle)
+                title = continueTitle;
+        }
+        // Check for subagents
+        const subagentFiles = await listSubagentFiles(jsonlPath);
+        // Filter out internal agents (prompt_suggestion, acompact) from user-visible count
+        // These are system agents that shouldn't appear in the subagent count
+        const userVisibleSubagents = subagentFiles.filter((f) => !f.agentId.startsWith('aprompt_suggestion-') &&
+            !f.agentId.startsWith('acompact-'));
+        // Track if auto-compact occurred (for showing indicator in UI)
+        const autoCompactFile = subagentFiles.find((f) => f.agentId.startsWith('acompact-'));
+        const hadAutoCompact = !!autoCompactFile;
+        const autoCompactAt = autoCompactFile?.modifiedAt.toISOString();
+        const hasSubagents = userVisibleSubagents.length > 0;
+        // Detect mode and plans
+        const { mode, planRefs } = detectModeAndPlans(entries);
+        // Extract explore agents and web searches (with token costs from subagent files)
+        const { exploreAgents, webSearches } = await extractAgentsAndSearches(entries, subagentFiles);
+        // Detect git info from project path
+        const gitInfo = await detectGitInfo(projectPath);
+        // If detectGitInfo failed (e.g., deleted worktree), read gitBranch from raw JSONL
+        if (!gitInfo.branch) {
+            gitInfo.branch = await readGitBranchFromJsonl(jsonlPath) || undefined;
+        }
+        // Use LAST turn's input tokens for context window size
+        // Each turn reports the FULL context, so summing would overcount
+        // Total context = fresh input + cache read (cache_creation is subset of fresh, not additional)
+        const totalInput = entryStats.lastInputTokens + entryStats.lastCacheRead;
+        // Use tiktoken-estimated output tokens (cumulative - each turn generates NEW output)
+        const totalOutput = entryStats.totalOutputTokensEstimated;
+        const hasTokens = totalInput > 0 || totalOutput > 0;
+        return {
+            id: sessionId,
+            jsonlPath,
+            projectPath,
+            projectSlug,
+            title,
+            startedAt,
+            endedAt,
+            messageCount: entryStats.userMessages + entryStats.assistantMessages,
+            toolCallCount: entryStats.toolCalls,
+            hasSubagents,
+            subagentIds: hasSubagents
+                ? userVisibleSubagents.map((f) => f.agentId)
+                : undefined,
+            hadAutoCompact: hadAutoCompact || undefined,
+            autoCompactAt: autoCompactAt || undefined,
+            tokens: hasTokens ? {
+                input: totalInput,
+                output: totalOutput,
+                cacheCreation: entryStats.lastCacheCreation,
+                cacheRead: entryStats.lastCacheRead,
+            } : undefined,
+            fileSizeBytes: stats.size,
+            modifiedAt: stats.mtime.toISOString(),
+            mode: mode || undefined,
+            planCount: planRefs.length > 0 ? planRefs.length : undefined,
+            planRefs: planRefs.length > 0 ? planRefs : undefined,
+            gitRepoRoot: gitInfo.repoRoot || undefined,
+            gitBranch: gitInfo.branch || undefined,
+            gitWorktree: gitInfo.worktree || undefined,
+            exploreAgents: exploreAgents.length > 0 ? exploreAgents : undefined,
+            webSearches: webSearches.length > 0 ? webSearches : undefined,
+        };
+    }
+    catch (err) {
+        const sessionId = path.basename(jsonlPath, ".jsonl");
+        logger.error(`Failed to extract metadata for ${sessionId}:`, getErrorMessage(err));
+        return null;
+    }
+}
+/**
+ * List all project directories in ~/.claude/projects/
+ */
+export async function listAllProjects() {
+    const projects = [];
+    try {
+        const entries = await fs.readdir(CLAUDE_PROJECTS_PATH, {
+            withFileTypes: true,
+        });
+        const dirs = entries.filter((e) => e.isDirectory());
+        // Decode all project paths in parallel (each reads sessions-index.json or first JSONL)
+        const results = await Promise.all(dirs.map(async (entry) => {
+            const projectPath = await decodeProjectPath(entry.name);
+            const projectSlug = path.basename(projectPath);
+            return {
+                encodedPath: path.join(CLAUDE_PROJECTS_PATH, entry.name),
+                projectPath,
+                projectSlug,
+            };
+        }));
+        projects.push(...results);
+    }
+    catch (err) {
+        if (!isNotFoundError(err)) {
+            logger.warn("Failed to list projects:", getErrorMessage(err));
+        }
+    }
+    return projects;
+}
+/**
+ * Build session entries from catalog data (fast path).
+ *
+ * For each project:
+ * 1. Read .jacques/index.json for catalog metadata
+ * 2. List JSONL files in the encoded project dir
+ * 3. Stat JSONL files for size/mtime (in parallel)
+ * 4. Convert catalog entries to SessionEntry
+ * 5. Identify uncataloged JSONL files for fallback parsing
+ */
+async function buildFromCatalog(projects) {
+    const catalogSessions = [];
+    const uncatalogedFiles = [];
+    for (const project of projects) {
+        // Read catalog index (returns empty default if missing)
+        const index = await readProjectIndex(project.projectPath);
+        // List JSONL files in the encoded project directory
+        let jsonlFilenames = [];
+        try {
+            const dirEntries = await fs.readdir(project.encodedPath, { withFileTypes: true });
+            jsonlFilenames = dirEntries
+                .filter((e) => e.isFile() && e.name.endsWith(".jsonl"))
+                .map((e) => e.name);
+        }
+        catch (err) {
+            if (!isNotFoundError(err)) {
+                logger.warn(`Skipping unreadable project dir ${project.projectSlug}:`, getErrorMessage(err));
+            }
+            continue;
+        }
+        // Build set of cataloged session IDs
+        const catalogedSessionIds = new Set(index.sessions.map((s) => s.id));
+        // Stat all JSONL files in parallel
+        const statResults = await Promise.all(jsonlFilenames.map(async (filename) => {
+            const jsonlPath = path.join(project.encodedPath, filename);
+            const sessionId = path.basename(filename, ".jsonl");
+            try {
+                const stats = await fs.stat(jsonlPath);
+                return { sessionId, jsonlPath, stats, filename };
+            }
+            catch {
+                return null; // File disappeared between readdir and stat (race condition)
+            }
+        }));
+        // Detect git info ONCE per project (not per session) — avoids spawning
+        // a git subprocess for every JSONL file in the same project directory.
+        const projectGitInfo = await detectGitInfo(project.projectPath);
+        if (!projectGitInfo.branch && jsonlFilenames.length > 0) {
+            projectGitInfo.branch = await readGitBranchFromJsonl(path.join(project.encodedPath, jsonlFilenames[0])) || undefined;
+        }
+        // If detectGitInfo failed (e.g., deleted worktree), try recovering
+        // gitRepoRoot from a previously-extracted session manifest.
+        if (!projectGitInfo.repoRoot) {
+            for (const result of statResults) {
+                if (!result)
+                    continue;
+                const manifest = await readSessionManifest(project.projectPath, result.sessionId);
+                if (manifest?.gitRepoRoot) {
+                    projectGitInfo.repoRoot = manifest.gitRepoRoot;
+                    if (!projectGitInfo.branch && manifest.gitBranch) {
+                        projectGitInfo.branch = manifest.gitBranch;
+                    }
+                    if (!projectGitInfo.worktree && manifest.gitWorktree) {
+                        projectGitInfo.worktree = manifest.gitWorktree;
+                    }
+                    break;
+                }
+            }
+        }
+        for (const result of statResults) {
+            if (!result)
+                continue;
+            const { sessionId, jsonlPath, stats } = result;
+            if (!catalogedSessionIds.has(sessionId)) {
+                // Not in catalog - needs JSONL parsing
+                uncatalogedFiles.push({
+                    filePath: jsonlPath,
+                    projectPath: project.projectPath,
+                    projectSlug: project.projectSlug,
+                });
+                continue;
+            }
+            // Find catalog session entry
+            const catalogSession = index.sessions.find((s) => s.id === sessionId);
+            if (!catalogSession)
+                continue;
+            // Staleness check: if JSONL is newer than catalog savedAt, re-parse
+            const jsonlMtime = stats.mtime.toISOString();
+            // Read the session manifest for planRefs and precise mtime check
+            const manifest = await readSessionManifest(project.projectPath, sessionId);
+            if (catalogSession.savedAt && jsonlMtime > catalogSession.savedAt) {
+                if (!manifest || jsonlMtime > manifest.jsonlModifiedAt) {
+                    uncatalogedFiles.push({
+                        filePath: jsonlPath,
+                        projectPath: project.projectPath,
+                        projectSlug: project.projectSlug,
+                    });
+                    continue;
+                }
+            }
+            // Map subagents from index
+            const exploreSubagents = index.subagents.filter((s) => s.sessionId === sessionId && s.type === "exploration");
+            const searchSubagents = index.subagents.filter((s) => s.sessionId === sessionId && s.type === "search");
+            // Use planRefs from manifest (preserves source: embedded/write/agent)
+            // Fall back to reconstructing from PlanEntry if manifest lacks planRefs
+            let planRefs = [];
+            if (manifest?.planRefs && manifest.planRefs.length > 0) {
+                // Manifest has full planRefs with correct source types
+                planRefs = manifest.planRefs.map((ref) => {
+                    // Find matching catalogId from planIds
+                    const catalogId = catalogSession.planIds?.find((pid) => index.plans.some((p) => p.id === pid));
+                    return {
+                        title: ref.title,
+                        source: ref.source,
+                        messageIndex: ref.messageIndex,
+                        filePath: ref.filePath,
+                        agentId: ref.agentId,
+                        catalogId: ref.catalogId || catalogId,
+                    };
+                });
+            }
+            else if (catalogSession.planIds) {
+                // Fallback: reconstruct from PlanEntry (older manifests without planRefs)
+                for (const planId of catalogSession.planIds) {
+                    const plan = index.plans.find((p) => p.id === planId);
+                    if (plan) {
+                        planRefs.push(catalogPlanToPlanRef(plan));
+                    }
+                }
+            }
+            const exploreAgents = exploreSubagents.map(catalogSubagentToExploreRef);
+            const webSearches = searchSubagents.map(catalogSubagentToSearchRef);
+            // Resolve continue session titles from handoff data
+            let resolvedTitle = catalogSession.title;
+            if (resolvedTitle && isContinueSession(resolvedTitle)) {
+                const continueTitle = await extractContinueTitleFromHandoff(project.projectPath, catalogSession.startedAt);
+                if (continueTitle)
+                    resolvedTitle = continueTitle;
+            }
+            // Build SessionEntry from catalog data + file stats
+            const entry = {
+                id: sessionId,
+                jsonlPath,
+                projectPath: project.projectPath,
+                projectSlug: project.projectSlug,
+                title: resolvedTitle,
+                startedAt: catalogSession.startedAt,
+                endedAt: catalogSession.endedAt,
+                messageCount: catalogSession.messageCount,
+                toolCallCount: catalogSession.toolCallCount,
+                hasSubagents: catalogSession.hasSubagents ?? false,
+                subagentIds: catalogSession.subagentIds,
+                hadAutoCompact: catalogSession.hadAutoCompact || undefined,
+                tokens: catalogSession.tokens,
+                fileSizeBytes: stats.size,
+                modifiedAt: stats.mtime.toISOString(),
+                mode: catalogSession.mode || undefined,
+                planCount: planRefs.length > 0 ? planRefs.length : (catalogSession.planCount || undefined),
+                planRefs: planRefs.length > 0 ? planRefs : undefined,
+                gitRepoRoot: projectGitInfo.repoRoot || undefined,
+                gitBranch: projectGitInfo.branch || undefined,
+                gitWorktree: projectGitInfo.worktree || undefined,
+                exploreAgents: exploreAgents.length > 0 ? exploreAgents : undefined,
+                webSearches: webSearches.length > 0 ? webSearches : undefined,
+            };
+            catalogSessions.push(entry);
+        }
+    }
+    return { catalogSessions, uncatalogedFiles };
+}
+/**
+ * Scan all sessions and build the index.
+ *
+ * Uses catalog-first loading: reads pre-extracted metadata from .jacques/index.json
+ * for each project, only falling back to JSONL parsing for new/uncataloged sessions.
+ */
+export async function buildSessionIndex(options) {
+    const { onProgress } = options || {};
+    onProgress?.({
+        phase: "scanning",
+        total: 0,
+        completed: 0,
+        current: "Scanning projects...",
+    });
+    // Get all projects
+    const projects = await listAllProjects();
+    // Phase 1: Read catalog data (fast - reads .jacques/index.json + stats JSONL files)
+    const { catalogSessions, uncatalogedFiles } = await buildFromCatalog(projects);
+    const totalFiles = catalogSessions.length + uncatalogedFiles.length;
+    onProgress?.({
+        phase: "processing",
+        total: totalFiles,
+        completed: catalogSessions.length,
+        current: `${catalogSessions.length} from catalog, ${uncatalogedFiles.length} to parse...`,
+    });
+    // Phase 2: Parse only uncataloged/stale sessions (slow path - only for new sessions)
+    const sessions = [...catalogSessions];
+    for (let i = 0; i < uncatalogedFiles.length; i++) {
+        const file = uncatalogedFiles[i];
+        const sessionId = path.basename(file.filePath, ".jsonl");
+        onProgress?.({
+            phase: "processing",
+            total: totalFiles,
+            completed: catalogSessions.length + i,
+            current: `${file.projectSlug}/${sessionId.substring(0, 8)}...`,
+        });
+        const metadata = await extractSessionMetadata(file.filePath, file.projectPath, file.projectSlug);
+        if (metadata) {
+            sessions.push(metadata);
+        }
+    }
+    // Sort by modification time (newest first)
+    sessions.sort((a, b) => new Date(b.modifiedAt).getTime() - new Date(a.modifiedAt).getTime());
+    const index = {
+        version: "2.0.0",
+        lastScanned: new Date().toISOString(),
+        sessions,
+    };
+    // Save to disk
+    await writeSessionIndex(index);
+    onProgress?.({
+        phase: "processing",
+        total: totalFiles,
+        completed: totalFiles,
+        current: "Complete",
+    });
+    return index;
+}
+//# sourceMappingURL=metadata-extractor.js.map