@getlore/cli 0.5.2 → 0.7.0

package/dist/mcp/handlers/sync.js

@@ -11,10 +11,10 @@
  *   - Generate embeddings
  *   - Store in Supabase + local data dir
  */
-import { readdir, readFile } from 'fs/promises';
+import { readdir, readFile, mkdir, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import path from 'path';
-import { getAllSources, addSource, resetDatabaseConnection, } from '../../core/vector-store.js';
+import { getAllSources, addSource, getSourcesWithPaths, resetDatabaseConnection, } from '../../core/vector-store.js';
 import { generateEmbedding, createSearchableText } from '../../core/embedder.js';
 import { gitPull, gitCommitAndPush } from '../../core/git.js';
 import { loadSyncConfig, getEnabledSources } from '../../sync/config.js';
@@ -106,6 +106,65 @@ async function legacyDiskSync(dbPath, dataDir) {
     return result;
 }
 // ============================================================================
+// Local Content Reconciliation
+// ============================================================================
+/**
+ * Ensures every source in Supabase with a source_path has a local
+ * ~/.lore/sources/{id}/content.md file. This handles:
+ * - Sources indexed before storeSourceToDisk was implemented
+ * - Sources from other machines (in shared Supabase but no local content)
+ * - Any edge case where Supabase write succeeded but disk write failed
+ *
+ * Cost: One Supabase query + local filesystem checks. No LLM calls.
+ */
+async function reconcileLocalContent(dataDir) {
+    const sourcesDir = path.join(dataDir, 'sources');
+    const textExts = ['.md', '.txt', '.json', '.jsonl', '.csv', '.xml', '.yaml', '.yml', '.html', '.log'];
+    // Get all sources that have a source_path in Supabase
+    const sourcesWithPaths = await getSourcesWithPaths('');
+    if (sourcesWithPaths.length === 0)
+        return 0;
+    let reconciled = 0;
+    for (const source of sourcesWithPaths) {
+        const sourceDir = path.join(sourcesDir, source.id);
+        const contentPath = path.join(sourceDir, 'content.md');
+        // Skip if content.md already exists
+        if (existsSync(contentPath))
+            continue;
+        // Try to create content.md from the original source_path
+        let content = null;
+        if (existsSync(source.source_path)) {
+            const ext = path.extname(source.source_path).toLowerCase();
+            if (textExts.includes(ext)) {
+                try {
+                    content = await readFile(source.source_path, 'utf-8');
+                }
+                catch {
+                    // File can't be read — fall through to summary
+                }
+            }
+        }
+        // If we couldn't read the original file, use the summary from Supabase
+        if (!content) {
+            content = [
+                `# ${source.title}`,
+                '',
+                source.summary,
+            ].join('\n');
+        }
+        // Create the source directory and content.md
+        try {
+            await mkdir(sourceDir, { recursive: true });
+            await writeFile(contentPath, content);
+            reconciled++;
+        }
+        catch {
+            // Skip on write failure — will retry on next sync
+        }
+    }
+    return reconciled;
+}
+// ============================================================================
 // Universal Sync (new system)
 // ============================================================================
 async function universalSync(dataDir, dryRun, hookContext) {
@@ -172,9 +231,12 @@ export async function handleSync(dbPath, dataDir, args, options = {}) {
         sources_found: 0,
         sources_indexed: 0,
         already_indexed: 0,
+        reconciled: 0,
     };
+    const { onProgress } = options;
     // 1. Git pull
     if (doPull) {
+        await onProgress?.(5, undefined, 'Pulling from git...');
         const pullResult = await gitPull(dataDir);
         result.git_pulled = pullResult.success && (pullResult.message?.includes('Pulled') || false);
         if (pullResult.error) {
@@ -188,20 +250,25 @@ export async function handleSync(dbPath, dataDir, args, options = {}) {
         const hasUniversalSources = getEnabledSources(config).length > 0;
         if (hasUniversalSources && !useLegacy) {
             // Use new universal sync
+            await onProgress?.(20, undefined, 'Discovering new files...');
             const { discovery, processing } = await universalSync(dataDir, dryRun, options.hookContext);
             result.discovery = discovery;
             result.processing = processing;
         }
         // Always run legacy disk sync for backward compatibility
         // (picks up sources added via old `lore ingest` command)
+        await onProgress?.(60, undefined, 'Running legacy sync...');
         const legacyResult = await legacyDiskSync(dbPath, dataDir);
         result.sources_found = legacyResult.sources_found;
         result.sources_indexed = legacyResult.sources_indexed;
         result.already_indexed = legacyResult.already_indexed;
+        // Reconcile: ensure every Supabase source has local content.md
+        await onProgress?.(80, undefined, 'Reconciling local content...');
+        result.reconciled = await reconcileLocalContent(dataDir);
     }
     // 3. Git push
     if (doPush && !dryRun) {
-        const totalNew = (result.processing?.processed || 0) + result.sources_indexed;
+        const totalNew = (result.processing?.processed || 0) + result.sources_indexed + result.reconciled;
         if (totalNew > 0) {
             const pushResult = await gitCommitAndPush(dataDir, `Sync: Added ${totalNew} source(s)`);
             result.git_pushed = pushResult.success && (pushResult.message?.includes('pushed') || false);

package/dist/mcp/server.js

@@ -21,7 +21,7 @@ import { handleGetSource } from './handlers/get-source.js';
 import { handleListSources } from './handlers/list-sources.js';
 import { handleRetain } from './handlers/retain.js';
 import { handleIngest } from './handlers/ingest.js';
-import { handleResearch } from './handlers/research.js';
+import { startResearchJob, getResearchJobStatus } from './handlers/research.js';
 import { handleListProjects } from './handlers/list-projects.js';
 import { handleSync } from './handlers/sync.js';
 import { handleArchiveProject } from './handlers/archive-project.js';
@@ -136,7 +136,7 @@ async function main() {
     }
     const server = new Server({
         name: 'lore',
-        version: '0.1.0',
+        version: '0.7.0',
     }, {
         capabilities: {
             tools: {},
@@ -184,8 +184,25 @@ async function main() {
         return { tools: toolDefinitions };
     });
     // Handle tool calls (core tools only)
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
+        // Build a progress callback for long-running tools.
+        // If the client sent a progressToken, we send notifications/progress back;
+        // otherwise, onProgress is a no-op.
+        const progressToken = request.params._meta?.progressToken;
+        const onProgress = progressToken
+            ? async (progress, total, message) => {
+                try {
+                    await extra.sendNotification({
+                        method: 'notifications/progress',
+                        params: { progressToken, progress, ...(total != null ? { total } : {}), ...(message ? { message } : {}) },
+                    });
+                }
+                catch {
+                    // Progress notifications are best-effort
+                }
+            }
+            : undefined;
         try {
             let result;
             switch (name) {
@@ -215,16 +232,22 @@ async function main() {
                         hookContext: { mode: 'mcp' },
                     });
                     break;
-                // Agentic research tool (uses Claude Agent SDK internally)
+                // Agentic research tool — runs async, returns job_id immediately
                 case 'research':
-                    result = await handleResearch(DB_PATH, LORE_DATA_DIR, args, {
+                    result = startResearchJob(DB_PATH, LORE_DATA_DIR, args, {
                         hookContext: { mode: 'mcp' },
+                        onProgress,
                     });
                     break;
+                // Poll for research results (long-polls up to 20s)
+                case 'research_status':
+                    result = await getResearchJobStatus(args?.job_id);
+                    break;
                 // Sync tool
                 case 'sync':
                     result = await handleSync(DB_PATH, LORE_DATA_DIR, args, {
                         hookContext: { mode: 'mcp' },
+                        onProgress,
                     });
                     break;
                 // Project management

package/dist/mcp/tools.js

@@ -241,7 +241,7 @@ USE 'ingest' INSTEAD for full documents, meeting notes, transcripts, or any cont
         name: 'research',
         description: `Run a comprehensive research query across the knowledge base. An internal agent iteratively searches, reads sources, cross-references findings, and synthesizes a research package with full citations.
 
-Returns: summary, key findings, supporting quotes with citations, conflicts detected between sources, and suggested follow-up queries.
+ASYNC: This tool returns immediately with a job_id. You MUST then poll 'research_status' with that job_id to get results. Research typically takes 2-8 minutes depending on the amount of data. Poll every 15-20 seconds. Do NOT assume it is stuck — check the 'activity' array in the status response to see what the agent is doing.
 
 WHEN TO USE:
 - Questions that span multiple sources ("What do we know about authentication?")
@@ -249,9 +249,23 @@ WHEN TO USE:
 - Building a cited research package for decision-making
 - Open-ended exploration of a topic
 
-COST: This tool makes multiple LLM calls internally (typically 3-8 search + read cycles). For simple lookups, use 'search' instead — it's 10x cheaper and faster.`,
+COST: This tool makes multiple LLM calls internally (typically 10-30 search + read cycles). For simple lookups, use 'search' instead — it's 10x cheaper and faster.`,
         inputSchema: zodToJsonSchema(ResearchSchema),
     },
+    // Research status (polling for async results)
+    {
+        name: 'research_status',
+        description: `Check the status of a running research job. Returns the full research package when complete.
+
+Call this after 'research' returns a job_id. Research typically takes 2-8 minutes. Poll every 15-20 seconds. The response includes an 'activity' array showing exactly what the research agent is doing (searches, sources being read, reasoning). As long as 'total_steps' is increasing or 'elapsed_seconds' is under 8 minutes, the research is progressing normally — do NOT abandon it.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'The job_id returned by the research tool' },
+            },
+            required: ['job_id'],
+        },
+    },
     // Ingest tool
     {
         name: 'ingest',

package/dist/sync/process.d.ts

@@ -16,6 +16,7 @@ import { type ImageMediaType } from './processors.js';
 export interface ExtractedMetadata {
     title: string;
     summary: string;
+    description?: string;
     date: string | null;
     participants: string[];
     content_type: ContentType;
@@ -38,6 +39,13 @@ export declare function extractMetadata(content: string, filePath: string, optio
         base64: string;
         mediaType: ImageMediaType;
     };
+    fileMetadata?: {
+        filename: string;
+        sizeBytes: number;
+        createdAt: string;
+        modifiedAt: string;
+        exif?: Record<string, unknown>;
+    };
 }): Promise<ExtractedMetadata>;
 export declare function processFiles(files: DiscoveredFile[], dataDir: string, options?: {
     onProgress?: (completed: number, total: number, title: string) => void;

package/dist/sync/process.js

@@ -55,12 +55,24 @@ Content type guidelines:
 
 Be specific in the summary. Include concrete details, names, numbers when present.`;
 export async function extractMetadata(content, filePath, options = {}) {
-    const { model = 'claude-sonnet-4-20250514', image } = options;
+    const { model = 'claude-sonnet-4-20250514', image, fileMetadata } = options;
     const client = getAnthropic();
     // Build message content based on whether we have an image or text
     let messageContent;
     if (image) {
-        // Image analysis with Claude Vision
+        // Image analysis with Claude Vision — extract metadata AND a detailed text description
+        const imagePrompt = `Analyze this image and return ONLY valid JSON with these fields:
+
+{
+  "title": "A descriptive title for this image",
+  "summary": "2-4 sentences capturing the key takeaway or purpose of this image",
+  "description": "A comprehensive text description of everything in this image. Include all text, data, labels, numbers, charts, diagrams, and visual elements. Transcribe any visible text verbatim. For charts/graphs, describe the data points and trends. For screenshots, describe the UI elements and content. Be thorough — this description replaces the image in a text-only knowledge base.",
+  "date": "ISO date string (YYYY-MM-DD) if mentioned, otherwise null",
+  "participants": ["list", "of", "names"] if people are mentioned, otherwise [],
+  "content_type": "one of: interview|meeting|conversation|document|note|analysis"
+}
+
+Be specific and thorough in the description. Include ALL visible text, numbers, and data.`;
         messageContent = [
             {
                 type: 'image',
@@ -72,7 +84,7 @@ export async function extractMetadata(content, filePath, options = {}) {
             },
             {
                 type: 'text',
-                text: `${EXTRACTION_PROMPT}\n\nFile: ${path.basename(filePath)}\n\nAnalyze this image and extract metadata. Describe what's in the image in detail in the summary.`,
+                text: `${imagePrompt}\n\nFile: ${path.basename(filePath)}${fileMetadata ? `\nFile size: ${(fileMetadata.sizeBytes / 1024).toFixed(0)} KB\nFile created: ${fileMetadata.createdAt}\nFile modified: ${fileMetadata.modifiedAt}${fileMetadata.exif ? `\nEXIF data: ${JSON.stringify(fileMetadata.exif)}` : ''}` : ''}`,
             },
         ];
     }
@@ -86,7 +98,7 @@ export async function extractMetadata(content, filePath, options = {}) {
     }
     const response = await client.messages.create({
         model,
-        max_tokens: 1000,
+        max_tokens: image ? 4000 : 1000,
         messages: [
             {
                 role: 'user',
@@ -111,6 +123,7 @@ export async function extractMetadata(content, filePath, options = {}) {
         return {
             title: parsed.title || path.basename(filePath),
             summary: parsed.summary || 'No summary available',
+            description: parsed.description || undefined,
             date: parsed.date || null,
             participants: Array.isArray(parsed.participants) ? parsed.participants : [],
             content_type: validateContentType(parsed.content_type),
@@ -150,9 +163,12 @@ async function storeSourceToDisk(sourceId, file, metadata, processedContent, dat
     const sourceDir = path.join(sourcesDir, sourceId);
     // Create source directory
     await mkdir(sourceDir, { recursive: true });
-    // Copy original file
-    const originalExt = path.extname(file.absolutePath);
-    await copyFile(file.absolutePath, path.join(sourceDir, `original${originalExt}`));
+    // Copy original file (skip binary formats — knowledge store is text-based)
+    const originalExt = path.extname(file.absolutePath).toLowerCase();
+    const binaryExts = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.tiff', '.ico', '.svg'];
+    if (!binaryExts.includes(originalExt)) {
+        await copyFile(file.absolutePath, path.join(sourceDir, `original${originalExt}`));
+    }
     // Save processed content
     await writeFile(path.join(sourceDir, 'content.md'), processedContent);
     // Save metadata
@@ -223,17 +239,59 @@ export async function processFiles(files, dataDir, options = {}) {
             // 1. Read and preprocess file
             const processed = await processFile(file.absolutePath);
             // 2. Extract metadata with Claude (handles both text and images)
-            const metadata = await extractMetadata(processed.text, file.absolutePath, { model, image: processed.image });
-            // For images, use the summary as the text content
-            const contentText = processed.image
-                ? `# ${metadata.title}\n\n${metadata.summary}`
-                : processed.text;
+            const metadata = await extractMetadata(processed.text, file.absolutePath, { model, image: processed.image, fileMetadata: processed.fileMetadata });
+            // For images, use the detailed description as the text content
+            let contentText;
+            if (processed.image) {
+                const lines = [
+                    `# ${metadata.title}`,
+                    '',
+                    metadata.description || metadata.summary,
+                    '',
+                    '---',
+                    '',
+                    `*Original file: ${path.basename(file.absolutePath)}*`,
+                    `*Synced from: ${file.sourceName}*`,
+                    metadata.date ? `*Date: ${metadata.date}*` : '',
+                ];
+                // Append EXIF metadata if available
+                const exif = processed.fileMetadata?.exif;
+                if (exif && Object.keys(exif).length > 0) {
+                    lines.push('');
+                    lines.push('## Image Metadata');
+                    for (const [key, value] of Object.entries(exif)) {
+                        if (value != null && value !== '') {
+                            const label = key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase()).trim();
+                            lines.push(`- **${label}:** ${Array.isArray(value) ? value.join(', ') : String(value)}`);
+                        }
+                    }
+                }
+                contentText = lines.filter(Boolean).join('\n');
+            }
+            else {
+                contentText = processed.text;
+            }
             // 3. Use existing ID for edits, generate new ID for new files
             const sourceId = file.existingId || generateSourceId();
-            // 4. Index in Supabase FIRST (may fail on duplicate content_hash)
-            await indexSource(sourceId, file, metadata, dbPath);
-            // 5. Store source to disk ONLY if Supabase succeeded
-            await storeSourceToDisk(sourceId, file, metadata, contentText, dataDir);
+            // 4. Store to disk FIRST — ensures content.md always exists
+            //    If this fails, we skip Supabase so the file stays "new" for retry.
+            try {
+                await storeSourceToDisk(sourceId, file, metadata, contentText, dataDir);
+            }
+            catch (diskError) {
+                console.error(`[process] Disk write failed for ${file.relativePath}: ${diskError}`);
+                throw new Error(`Disk write failed for ${file.relativePath}: ${diskError}`);
+            }
+            // 5. Index in Supabase — if this fails, disk content still exists
+            //    and legacy sync will pick it up on the next run.
+            try {
+                await indexSource(sourceId, file, metadata, dbPath);
+            }
+            catch (supabaseError) {
+                console.error(`[process] Supabase index failed for ${file.relativePath}: ${supabaseError}`);
+                console.error(`[process] Content saved to disk — will be indexed on next sync via legacy path`);
+                // Don't re-throw: disk write succeeded, source is safe
+            }
             if (extensionRegistry && hookContext) {
                 await extensionRegistry.runHook('onSourceCreated', {
                     id: sourceId,
@@ -265,9 +323,11 @@ export async function processFiles(files, dataDir, options = {}) {
                 onProgress?.(result.processed.length + result.errors.length, files.length, batchResult.value.metadata.title);
             }
             else {
+                const errorMsg = batchResult.reason?.message || String(batchResult.reason);
+                console.error(`[process] Failed to process ${file.relativePath}: ${errorMsg}`);
                 result.errors.push({
                     file,
-                    error: batchResult.reason?.message || String(batchResult.reason),
+                    error: errorMsg,
                 });
                 onProgress?.(result.processed.length + result.errors.length, files.length, `Error: ${file.relativePath}`);
             }

package/dist/sync/processors.d.ts

@@ -17,6 +17,13 @@ export interface ProcessedContent {
         base64: string;
         mediaType: ImageMediaType;
     };
+    fileMetadata?: {
+        filename: string;
+        sizeBytes: number;
+        createdAt: string;
+        modifiedAt: string;
+        exif?: Record<string, unknown>;
+    };
 }
 export declare function processFile(filePath: string): Promise<ProcessedContent>;
 export declare function preprocessFiles(filePaths: string[], options?: {

package/dist/sync/processors.js

@@ -4,7 +4,7 @@
  * Converts various file formats to plain text for Claude analysis.
  * All processing is IN MEMORY ONLY - original files are never modified.
  */
-import { readFile } from 'fs/promises';
+import { readFile, stat } from 'fs/promises';
 import path from 'path';
 let pdfParser = null;
 async function getPdfParser() {
@@ -196,13 +196,107 @@ async function processImage(filePath) {
     }
     const buffer = await readFile(filePath);
     const base64 = buffer.toString('base64');
+    // Extract file-level metadata
+    const fileStat = await stat(filePath);
+    const filename = path.basename(filePath);
+    // Try to parse date from common filename patterns (e.g. WhatsApp, screenshots)
+    let dateFromFilename;
+    const whatsappMatch = filename.match(/(\d{4}-\d{2}-\d{2})/);
+    if (whatsappMatch) {
+        dateFromFilename = whatsappMatch[1];
+    }
+    // Extract EXIF metadata (GPS, camera, date, etc.)
+    let exifData;
+    try {
+        const exifr = await import('exifr');
+        const raw = await exifr.default.parse(buffer, {
+            // Request all available tags
+            tiff: true,
+            exif: true,
+            gps: true,
+            icc: false, // Skip color profile (not useful for knowledge)
+            iptc: true, // Keywords, captions, copyright
+            xmp: true, // Extended metadata
+        });
+        if (raw) {
+            // Extract the most useful fields
+            exifData = {};
+            // Camera info
+            if (raw.Make)
+                exifData.cameraMake = raw.Make;
+            if (raw.Model)
+                exifData.cameraModel = raw.Model;
+            if (raw.LensModel)
+                exifData.lens = raw.LensModel;
+            // Date
+            if (raw.DateTimeOriginal)
+                exifData.dateTaken = raw.DateTimeOriginal instanceof Date ? raw.DateTimeOriginal.toISOString() : String(raw.DateTimeOriginal);
+            if (raw.CreateDate)
+                exifData.dateCreated = raw.CreateDate instanceof Date ? raw.CreateDate.toISOString() : String(raw.CreateDate);
+            // GPS
+            if (raw.latitude != null && raw.longitude != null) {
+                exifData.gpsLatitude = raw.latitude;
+                exifData.gpsLongitude = raw.longitude;
+            }
+            if (raw.GPSAltitude != null)
+                exifData.gpsAltitude = raw.GPSAltitude;
+            // Image dimensions
+            if (raw.ImageWidth)
+                exifData.width = raw.ImageWidth;
+            if (raw.ImageHeight)
+                exifData.height = raw.ImageHeight;
+            if (raw.ExifImageWidth)
+                exifData.width = raw.ExifImageWidth;
+            if (raw.ExifImageHeight)
+                exifData.height = raw.ExifImageHeight;
+            // Software / source
+            if (raw.Software)
+                exifData.software = raw.Software;
+            if (raw.Artist)
+                exifData.artist = raw.Artist;
+            if (raw.Copyright)
+                exifData.copyright = raw.Copyright;
+            // IPTC/XMP tags
+            if (raw.Keywords)
+                exifData.keywords = raw.Keywords;
+            if (raw.Description)
+                exifData.description = raw.Description;
+            if (raw.Caption)
+                exifData.caption = raw.Caption;
+            if (raw.Subject)
+                exifData.subject = raw.Subject;
+            if (raw.Title)
+                exifData.title = raw.Title;
+            // Use EXIF date if no filename date
+            if (!dateFromFilename && exifData.dateTaken) {
+                const d = new Date(exifData.dateTaken);
+                if (!isNaN(d.getTime())) {
+                    dateFromFilename = d.toISOString().split('T')[0];
+                }
+            }
+            // Drop empty objects
+            if (Object.keys(exifData).length === 0)
+                exifData = undefined;
+        }
+    }
+    catch (exifError) {
+        console.error(`[processors] EXIF extraction failed for ${path.basename(filePath)}: ${exifError}`);
+    }
     return {
         text: '', // Will be filled by Claude vision
         format: 'image',
+        metadata: dateFromFilename ? { date: dateFromFilename } : undefined,
         image: {
             base64,
             mediaType,
         },
+        fileMetadata: {
+            filename,
+            sizeBytes: fileStat.size,
+            createdAt: fileStat.birthtime.toISOString(),
+            modifiedAt: fileStat.mtime.toISOString(),
+            ...(exifData ? { exif: exifData } : {}),
+        },
     };
 }
 // ============================================================================

package/dist/tui/browse-handlers.js

@@ -90,47 +90,85 @@ export async function loadFullContent(state, ui, dbPath, sourcesDir) {
     const source = getSelectedSource(state);
     if (!source)
         return;
-    // Try to load from disk first
-    const contentPath = path.join(sourcesDir, source.id, 'content.md');
+    // Try to load from disk first (content.md, then original file)
+    const sourceDir = path.join(sourcesDir, source.id);
+    const contentPath = path.join(sourceDir, 'content.md');
     try {
         const { readFile } = await import('fs/promises');
         state.fullContent = await readFile(contentPath, 'utf-8');
     }
     catch {
-        // Fall back to database source details
-        const details = await getSourceById(dbPath, source.id);
-        if (details) {
-            state.fullContent = [
-                `# ${details.title}`,
-                '',
-                `**Type:** ${details.source_type} · ${details.content_type}`,
-                `**Date:** ${formatDate(details.created_at)}`,
-                `**Projects:** ${details.projects.join(', ') || '(none)'}`,
-                '',
-                '## Summary',
-                details.summary,
-                '',
-            ].join('\n');
-            if (details.themes && details.themes.length > 0) {
-                state.fullContent += '## Themes\n';
-                for (const theme of details.themes) {
-                    state.fullContent += `- **${theme.name}**`;
-                    if (theme.summary)
-                        state.fullContent += `: ${theme.summary}`;
-                    state.fullContent += '\n';
+        // content.md not found — try to find and read an original text file
+        let foundOriginal = false;
+        try {
+            const { readFile, readdir } = await import('fs/promises');
+            const files = await readdir(sourceDir);
+            const originalFile = files.find(f => f.startsWith('original.'));
+            if (originalFile) {
+                const textExts = ['.md', '.txt', '.json', '.jsonl', '.csv', '.xml', '.yaml', '.yml', '.html', '.log'];
+                const ext = path.extname(originalFile).toLowerCase();
+                if (textExts.includes(ext)) {
+                    state.fullContent = await readFile(path.join(sourceDir, originalFile), 'utf-8');
+                    foundOriginal = true;
                 }
-                state.fullContent += '\n';
             }
-            if (details.quotes && details.quotes.length > 0) {
-                state.fullContent += '## Key Quotes\n';
-                for (const quote of details.quotes.slice(0, 10)) {
-                    const speaker = quote.speaker === 'user' ? '[You]' : `[${quote.speaker_name || 'Participant'}]`;
-                    state.fullContent += `> ${speaker} "${quote.text}"\n\n`;
+        }
+        catch {
+            // Source directory doesn't exist locally — fall through to DB
+        }
+        if (!foundOriginal) {
+            // Try reading from source_path (original file in sync directory)
+            const details = await getSourceById(dbPath, source.id);
+            if (details?.source_path) {
+                try {
+                    const { readFile } = await import('fs/promises');
+                    const ext = path.extname(details.source_path).toLowerCase();
+                    const textExts = ['.md', '.txt', '.json', '.jsonl', '.csv', '.xml', '.yaml', '.yml', '.html', '.log'];
+                    if (textExts.includes(ext)) {
+                        state.fullContent = await readFile(details.source_path, 'utf-8');
+                        foundOriginal = true;
+                    }
+                }
+                catch {
+                    // source_path file doesn't exist or can't be read
+                }
+            }
+            if (!foundOriginal) {
+                // Final fallback: database summary view
+                if (details) {
+                    state.fullContent = [
+                        `# ${details.title}`,
+                        '',
+                        `**Type:** ${details.source_type} · ${details.content_type}`,
+                        `**Date:** ${formatDate(details.created_at)}`,
+                        `**Projects:** ${details.projects.join(', ') || '(none)'}`,
+                        '',
+                        '## Summary',
+                        details.summary,
+                        '',
+                    ].join('\n');
+                    if (details.themes && details.themes.length > 0) {
+                        state.fullContent += '## Themes\n';
+                        for (const theme of details.themes) {
+                            state.fullContent += `- **${theme.name}**`;
+                            if (theme.summary)
+                                state.fullContent += `: ${theme.summary}`;
+                            state.fullContent += '\n';
+                        }
+                        state.fullContent += '\n';
+                    }
+                    if (details.quotes && details.quotes.length > 0) {
+                        state.fullContent += '## Key Quotes\n';
+                        for (const quote of details.quotes.slice(0, 10)) {
+                            const speaker = quote.speaker === 'user' ? '[You]' : `[${quote.speaker_name || 'Participant'}]`;
+                            state.fullContent += `> ${speaker} "${quote.text}"\n\n`;
+                        }
+                    }
+                }
+                else {
+                    state.fullContent = `Could not load content for ${source.title}`;
                 }
             }
-        }
-        else {
-            state.fullContent = `Could not load content for ${source.title}`;
         }
     }
     // Store raw lines for searching
@@ -370,6 +408,7 @@ export async function applyFilter(state, ui, query, filterMode, dbPath, dataDir,
                 content_type: r.content_type,
                 projects: r.projects,
                 created_at: r.created_at,
+                indexed_at: r.created_at,
                 summary: r.summary,
                 score: r.score,
             }));