@getlore/cli 0.5.2 → 0.7.0

package/LICENSE

@@ -1,8 +1,16 @@
-Copyright (c) 2026 Mishkin Faustini. All rights reserved.
+MIT License
 
-This software is proprietary and confidential. No part of this software
-may be reproduced, distributed, or transmitted in any form or by any means
-without the prior written permission of the copyright holder.
+Copyright (c) 2026 Mishkin Faustini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

package/README.md

@@ -1,6 +1,8 @@
 # Lore
 
-> The lore behind your projects.
+> The lore behind your projects. — [getlore.ai](https://getlore.ai) · [npm](https://www.npmjs.com/package/@getlore/cli)
+
+Every project accumulates lore — the decisions, conversations, research, and context that explain why things are the way they are. Most of it gets lost between chat threads and forgotten docs. Lore keeps it searchable and citable.
 
 A research knowledge repository with **semantic search** and **citations**. Unlike memory systems that store processed facts, Lore preserves your original sources and lets you cite exactly what was said, by whom, and when.
 
@@ -31,14 +33,23 @@ lore search "user pain points"
 
 ## MCP Configuration
 
-Add to your Claude Code or Claude Desktop MCP config:
+**One-click install:**
+
+[![Install in Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=lore&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBnZXRsb3JlL2NsaSIsIm1jcCJdfQ%3D%3D)
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=lore&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40getlore%2Fcli%22%2C%22mcp%22%5D%7D)
+[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_Server-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=lore&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40getlore%2Fcli%22%2C%22mcp%22%5D%7D&quality=insiders)
+[![Install in Goose](https://img.shields.io/badge/Goose-Install_Extension-F97316?style=flat-square&logoColor=white)](goose://extension?cmd=npx&arg=-y&arg=%40getlore%2Fcli&arg=mcp&timeout=300&id=lore-mcp&name=Lore&description=Research%20knowledge%20repository%20with%20semantic%20search%20and%20citations)
+
+After installing, run `npx @getlore/cli setup` to configure API keys and sign in.
+
+**Manual config** — add to your MCP client config (`.mcp.json`, `.cursor/mcp.json`, etc.):
 
 ```json
 {
   "mcpServers": {
     "lore": {
-      "command": "lore",
-      "args": ["mcp"]
+      "command": "npx",
+      "args": ["-y", "@getlore/cli", "mcp"]
     }
   }
 }
@@ -75,6 +86,56 @@ If the MCP host doesn't inherit your shell environment (e.g. Claude Desktop), ad
 
 Same content on different machines produces the same hash — no duplicate processing.
 
+## Agent Platform Install
+
+Lore works with any agent that supports MCP. Use `lore skills install` or install directly from your platform's registry.
+
+### Claude Code
+
+```bash
+# From plugin directory (once approved)
+/plugin install lore
+
+# Or install directly from GitHub
+/plugin install https://github.com/getlore-ai/lore/tree/main/plugins/claude-code
+
+# Or via Lore CLI
+lore skills install claude-code
+```
+
+### Gemini CLI
+
+```bash
+# From Extensions Gallery
+gemini extensions install lore
+
+# Or install directly from GitHub
+gemini extensions install https://github.com/getlore-ai/lore --path plugins/gemini
+
+# Or via Lore CLI
+lore skills install gemini
+```
+
+### Codex CLI
+
+```bash
+# Add MCP server
+codex mcp add lore -- npx -y @getlore/cli mcp
+
+# Install skill
+lore skills install codex
+```
+
+### OpenClaw
+
+```bash
+# From ClawHub
+clawhub install lore
+
+# Or via Lore CLI
+lore skills install openclaw
+```
+
 ## License
 
-Proprietary. All rights reserved.
+MIT

package/dist/cli/commands/sync.js

@@ -205,7 +205,7 @@ export function registerSyncCommand(program, defaultDataDir) {
                 console.log(`  ... and ${result.processing.titles.length - 10} more`);
             }
             if (result.processing.errors > 0) {
-                console.log(`  Errors: ${result.processing.errors}`);
+                console.log(`  ⚠ ${result.processing.errors} file(s) failed to process (check logs above)`);
             }
         }
         if (result.sources_found > 0 || result.sources_indexed > 0) {
@@ -214,6 +214,9 @@ export function registerSyncCommand(program, defaultDataDir) {
             console.log(`  Newly indexed: ${result.sources_indexed}`);
             console.log(`  Already indexed: ${result.already_indexed}`);
         }
+        if (result.reconciled > 0) {
+            console.log(`\nReconciled ${result.reconciled} source(s) missing local content`);
+        }
         if (result.git_pushed) {
             console.log('\n✓ Pushed changes to git');
         }

package/dist/core/git.js

@@ -51,11 +51,43 @@ export async function gitPull(dir) {
         if (!(await hasRemote(dir))) {
             return { success: false, error: 'No remote configured' };
         }
-        // Stash any local changes
-        await execAsync('git stash', { cwd: dir }).catch(() => { });
+        // Stash any local changes before pulling
+        let didStash = false;
+        if (await hasChanges(dir)) {
+            try {
+                const { stdout: stashOut } = await execAsync('git stash', { cwd: dir });
+                didStash = !stashOut.includes('No local changes');
+            }
+            catch (stashErr) {
+                console.error(`[git] Stash failed: ${stashErr}`);
+            }
+        }
         // Pull with rebase
-        const { stdout } = await execAsync('git pull --rebase', { cwd: dir });
-        const pulled = !stdout.includes('Already up to date');
+        let pullOutput;
+        try {
+            const { stdout } = await execAsync('git pull --rebase', { cwd: dir });
+            pullOutput = stdout;
+        }
+        catch (pullErr) {
+            // Restore stashed changes before returning error
+            if (didStash) {
+                await execAsync('git stash pop', { cwd: dir }).catch((popErr) => {
+                    console.error(`[git] Stash pop failed after pull error: ${popErr}`);
+                });
+            }
+            throw pullErr;
+        }
+        // Restore stashed changes after successful pull
+        if (didStash) {
+            try {
+                await execAsync('git stash pop', { cwd: dir });
+            }
+            catch (popErr) {
+                console.error(`[git] Stash pop failed (possible conflict): ${popErr}`);
+                // Don't fail the pull — stashed content is still in `git stash list`
+            }
+        }
+        const pulled = !pullOutput.includes('Already up to date');
         return {
             success: true,
             message: pulled ? 'Pulled new changes' : 'Already up to date'

package/dist/core/vector-store.d.ts

@@ -79,6 +79,7 @@ export declare function getAllSources(_dbPath: string, options?: {
     project?: string;
     source_type?: SourceType;
     limit?: number;
+    sort_by?: 'indexed_at' | 'created_at';
 }): Promise<Array<{
     id: string;
     title: string;
@@ -86,8 +87,19 @@ export declare function getAllSources(_dbPath: string, options?: {
     content_type: ContentType;
     projects: string[];
     created_at: string;
+    indexed_at: string;
     summary: string;
 }>>;
+/**
+ * Get all sources that have a source_path set.
+ * Used by reconciliation to ensure local content.md files exist.
+ */
+export declare function getSourcesWithPaths(_dbPath: string): Promise<Array<{
+    id: string;
+    title: string;
+    summary: string;
+    source_path: string;
+}>>;
 export declare function getSourceById(_dbPath: string, sourceId: string): Promise<{
     id: string;
     title: string;
@@ -101,6 +113,7 @@ export declare function getSourceById(_dbPath: string, sourceId: string): Promis
     quotes: Quote[];
     source_url?: string;
     source_name?: string;
+    source_path?: string;
 } | null>;
 export declare function deleteSource(_dbPath: string, sourceId: string): Promise<{
     deleted: boolean;

package/dist/core/vector-store.js

@@ -321,12 +321,12 @@ export async function searchSources(_dbPath, queryVector, options = {}) {
 // Retrieval Operations
 // ============================================================================
 export async function getAllSources(_dbPath, options = {}) {
-    const { project, source_type, limit } = options;
+    const { project, source_type, limit, sort_by = 'indexed_at' } = options;
     const client = await getSupabase();
     let query = client
         .from('sources')
-        .select('id, title, source_type, content_type, projects, created_at, summary')
-        .order('created_at', { ascending: false });
+        .select('id, title, source_type, content_type, projects, created_at, indexed_at, summary')
+        .order(sort_by, { ascending: false });
     if (source_type) {
         query = query.eq('source_type', source_type);
     }
@@ -348,9 +348,33 @@ export async function getAllSources(_dbPath, options = {}) {
         content_type: row.content_type,
         projects: row.projects,
         created_at: row.created_at,
+        indexed_at: row.indexed_at || row.created_at,
         summary: row.summary,
     }));
 }
+/**
+ * Get all sources that have a source_path set.
+ * Used by reconciliation to ensure local content.md files exist.
+ */
+export async function getSourcesWithPaths(_dbPath) {
+    const client = await getSupabase();
+    const { data, error } = await client
+        .from('sources')
+        .select('id, title, summary, source_path')
+        .not('source_path', 'is', null);
+    if (error) {
+        console.error('Error getting sources with paths:', error);
+        return [];
+    }
+    return (data || [])
+        .filter((row) => row.source_path)
+        .map((row) => ({
+        id: row.id,
+        title: row.title,
+        summary: row.summary || '',
+        source_path: row.source_path,
+    }));
+}
 export async function getSourceById(_dbPath, sourceId) {
     const client = await getSupabase();
     const { data, error } = await client
@@ -375,6 +399,7 @@ export async function getSourceById(_dbPath, sourceId) {
         quotes: data.quotes_json || [],
         source_url: data.source_url || undefined,
         source_name: data.source_name || undefined,
+        source_path: data.source_path || undefined,
     };
 }
 export async function deleteSource(_dbPath, sourceId) {

package/dist/mcp/handlers/research-agent.d.ts

@@ -8,6 +8,7 @@
  * 4. Synthesizes findings into a comprehensive research package
  */
 import type { ResearchPackage } from '../../core/types.js';
+import type { ProgressCallback } from './research.js';
 interface ResearchAgentArgs {
     task: string;
     project?: string;
@@ -17,5 +18,5 @@ interface ResearchAgentArgs {
 /**
  * Run the agentic research
  */
-export declare function runResearchAgent(dbPath: string, dataDir: string, args: ResearchAgentArgs): Promise<ResearchPackage>;
+export declare function runResearchAgent(dbPath: string, dataDir: string, args: ResearchAgentArgs, onProgress?: ProgressCallback): Promise<ResearchPackage>;
 export {};

package/dist/mcp/handlers/research-agent.js

@@ -232,7 +232,7 @@ Now begin your research. Use the tools iteratively until you have comprehensive
 /**
  * Run the agentic research
  */
-export async function runResearchAgent(dbPath, dataDir, args) {
+export async function runResearchAgent(dbPath, dataDir, args, onProgress) {
     const { task, project, include_sources = true } = args;
     // Load archived projects to filter (extract just the project names)
     const archivedProjectsData = await loadArchivedProjects(dataDir);
@@ -245,6 +245,8 @@ export async function runResearchAgent(dbPath, dataDir, args) {
     let lastAssistantMessage = '';
     try {
         // Run the agent
+        let turnCount = 0;
+        await onProgress?.(5, undefined, 'Starting research agent...');
         for await (const message of query({
             prompt: `Research task: ${task}${project ? ` (project: ${project})` : ''}`,
             options: {
@@ -261,8 +263,9 @@ export async function runResearchAgent(dbPath, dataDir, args) {
                 permissionMode: 'acceptEdits', // Auto-approve tool calls
             },
         })) {
-            // Capture assistant messages (intermediate)
+            // Capture assistant messages and extract tool call details
             if (message.type === 'assistant') {
+                turnCount++;
                 const msg = message;
                 if (msg.message?.content) {
                     const content = msg.message.content;
@@ -270,9 +273,30 @@ export async function runResearchAgent(dbPath, dataDir, args) {
                         lastAssistantMessage = content;
                     }
                     else if (Array.isArray(content)) {
-                        const textBlocks = content.filter((b) => b.type === 'text');
-                        if (textBlocks.length > 0) {
-                            lastAssistantMessage = textBlocks.map((b) => b.text).join('\n');
+                        // Extract tool_use blocks to report what the agent is doing
+                        for (const block of content) {
+                            if (block.type === 'tool_use') {
+                                const input = block.input;
+                                const toolShort = block.name.replace('mcp__lore-tools__', '');
+                                if (toolShort === 'search' && input.query) {
+                                    await onProgress?.(0, undefined, `Searching: "${input.query}"`);
+                                }
+                                else if (toolShort === 'get_source' && input.source_id) {
+                                    await onProgress?.(0, undefined, `Reading source: ${input.source_id}`);
+                                }
+                                else if (toolShort === 'list_sources') {
+                                    const filter = input.project ? ` (project: ${input.project})` : '';
+                                    await onProgress?.(0, undefined, `Listing sources${filter}`);
+                                }
+                            }
+                            else if (block.type === 'text' && block.text) {
+                                lastAssistantMessage = block.text;
+                                // Send a brief snippet of agent reasoning
+                                const snippet = block.text.substring(0, 120).replace(/\n/g, ' ');
+                                if (snippet.length > 10) {
+                                    await onProgress?.(0, undefined, `Agent thinking: ${snippet}...`);
+                                }
+                            }
                         }
                     }
                 }
@@ -282,16 +306,22 @@ export async function runResearchAgent(dbPath, dataDir, args) {
                 const msg = message;
                 if (msg.subtype === 'success' && msg.result) {
                     lastAssistantMessage = msg.result;
+                    await onProgress?.(0, undefined, `Research complete (${msg.num_turns} turns)`);
                     console.error(`[research-agent] Completed in ${msg.num_turns} turns`);
                 }
                 else if (msg.subtype?.startsWith('error')) {
                     console.error(`[research-agent] Error: ${msg.subtype}`, msg.errors);
                 }
             }
-            // Log tool usage for debugging
+            // Log tool results via the summary message
             if (message.type === 'tool_use_summary') {
                 const msg = message;
-                console.error(`[research-agent] Tool: ${msg.tool_name || 'unknown'}`);
+                if (msg.summary) {
+                    // The summary often contains "Found X results" or similar
+                    const summarySnippet = msg.summary.substring(0, 150).replace(/\n/g, ' ');
+                    await onProgress?.(0, undefined, `Result: ${summarySnippet}`);
+                }
+                console.error(`[research-agent] Tool complete (turn ${turnCount})`);
             }
         }
         // Parse the final result from the agent's output

package/dist/mcp/handlers/research.d.ts

@@ -6,17 +6,36 @@
  * 2. SIMPLE (fallback): Single-pass search + GPT-4o-mini synthesis
  *
  * Set LORE_RESEARCH_MODE=simple to use the fallback mode.
+ *
+ * MCP integration: Research runs asynchronously. The `research` tool returns
+ * immediately with a job_id. Use `research_status` to poll for results.
  */
 import type { ResearchPackage } from '../../core/types.js';
+/**
+ * Start research asynchronously and return a job ID immediately.
+ */
+export declare function startResearchJob(dbPath: string, dataDir: string, args: ResearchArgs, options?: {
+    hookContext?: {
+        mode: 'mcp' | 'cli';
+    };
+    onProgress?: ProgressCallback;
+}): {
+    job_id: string;
+    status: string;
+    message: string;
+};
+export declare function getResearchJobStatus(jobId: string): Promise<Record<string, unknown>>;
 interface ResearchArgs {
     task: string;
     project?: string;
     content_type?: string;
     include_sources?: boolean;
 }
+export type ProgressCallback = (progress: number, total?: number, message?: string) => Promise<void>;
 export declare function handleResearch(dbPath: string, dataDir: string, args: ResearchArgs, options?: {
     hookContext?: {
         mode: 'mcp' | 'cli';
     };
+    onProgress?: ProgressCallback;
 }): Promise<ResearchPackage>;
 export {};

package/dist/mcp/handlers/research.js

@@ -6,13 +6,145 @@
  * 2. SIMPLE (fallback): Single-pass search + GPT-4o-mini synthesis
  *
  * Set LORE_RESEARCH_MODE=simple to use the fallback mode.
+ *
+ * MCP integration: Research runs asynchronously. The `research` tool returns
+ * immediately with a job_id. Use `research_status` to poll for results.
  */
 import OpenAI from 'openai';
+import { randomUUID } from 'crypto';
 import { searchSources } from '../../core/vector-store.js';
 import { generateEmbedding } from '../../core/embedder.js';
 import { loadArchivedProjects } from './archive-project.js';
 import { runResearchAgent } from './research-agent.js';
 import { getExtensionRegistry } from '../../extensions/registry.js';
+const jobStore = new Map();
+// Clean up old jobs after 10 minutes
+const JOB_TTL_MS = 10 * 60 * 1000;
+function cleanOldJobs() {
+    const now = Date.now();
+    for (const [id, job] of jobStore) {
+        const startTime = new Date(job.startedAt).getTime();
+        if (now - startTime > JOB_TTL_MS) {
+            jobStore.delete(id);
+        }
+    }
+}
+/**
+ * Start research asynchronously and return a job ID immediately.
+ */
+export function startResearchJob(dbPath, dataDir, args, options = {}) {
+    cleanOldJobs();
+    const jobId = randomUUID();
+    const now = new Date().toISOString();
+    const job = {
+        id: jobId,
+        task: args.task,
+        project: args.project,
+        status: 'running',
+        startedAt: now,
+        lastActivityAt: now,
+        activity: ['Starting research...'],
+    };
+    jobStore.set(jobId, job);
+    // Fire and forget — runs in the background
+    handleResearch(dbPath, dataDir, args, {
+        ...options,
+        onProgress: async (_p, _t, message) => {
+            const j = jobStore.get(jobId);
+            if (j && message) {
+                j.activity.push(message);
+                j.lastActivityAt = new Date().toISOString();
+            }
+        },
+    })
+        .then((result) => {
+        const j = jobStore.get(jobId);
+        if (j) {
+            j.status = 'complete';
+            j.completedAt = new Date().toISOString();
+            j.result = result;
+            j.activity.push('Research complete');
+        }
+    })
+        .catch((err) => {
+        const j = jobStore.get(jobId);
+        if (j) {
+            j.status = 'error';
+            j.completedAt = new Date().toISOString();
+            j.error = err instanceof Error ? err.message : String(err);
+            j.activity.push(`Failed: ${j.error}`);
+        }
+    })
+        .catch((err) => {
+        // Final safety net for errors in the handlers above
+        console.error(`[research] Critical error in job ${jobId}:`, err);
+    });
+    return {
+        job_id: jobId,
+        status: 'running',
+        message: `Research started for: "${args.task}". Poll research_status with job_id "${jobId}" every 15-20 seconds. This typically takes 2-8 minutes — do not abandon early.`,
+    };
+}
+/**
+ * Check status of a research job.
+ * Long-polls for up to POLL_WAIT_MS, returning early if the job completes.
+ */
+const POLL_WAIT_MS = 20_000;
+const POLL_INTERVAL_MS = 1_000;
+export async function getResearchJobStatus(jobId) {
+    let job = jobStore.get(jobId);
+    if (!job) {
+        return { status: 'not_found', job_id: jobId };
+    }
+    // If already done, return immediately
+    if (job.status !== 'running') {
+        return formatJobResponse(job);
+    }
+    // Long-poll: wait up to POLL_WAIT_MS for completion, checking every second
+    const deadline = Date.now() + POLL_WAIT_MS;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        // Re-fetch to avoid stale reference if job was cleaned up
+        job = jobStore.get(jobId);
+        if (!job) {
+            return { status: 'not_found', job_id: jobId };
+        }
+        if (job.status !== 'running') {
+            return formatJobResponse(job);
+        }
+    }
+    return formatJobResponse(job);
+}
+function formatJobResponse(job) {
+    const elapsed = Math.round((Date.now() - new Date(job.startedAt).getTime()) / 1000);
+    if (job.status === 'complete') {
+        return {
+            status: 'complete',
+            job_id: job.id,
+            task: job.task,
+            elapsed_seconds: elapsed,
+            result: job.result,
+        };
+    }
+    if (job.status === 'error') {
+        return {
+            status: 'error',
+            job_id: job.id,
+            task: job.task,
+            elapsed_seconds: elapsed,
+            error: job.error,
+        };
+    }
+    return {
+        status: 'running',
+        job_id: job.id,
+        task: job.task,
+        elapsed_seconds: elapsed,
+        total_steps: job.activity.length,
+        activity: job.activity,
+        message: `Research is still running (${elapsed}s elapsed, ${job.activity.length} steps completed). This is normal — deep research takes 2-8 minutes. Keep polling.`,
+    };
+}
 // Lazy initialization for OpenAI (only used in simple mode)
 let openaiClient = null;
 function getOpenAI() {
@@ -109,12 +241,15 @@ Respond with only the JSON object.`;
 }
 export async function handleResearch(dbPath, dataDir, args, options = {}) {
     const { task, project, include_sources = true } = args;
+    const { onProgress } = options;
     // Check if we should use agentic mode (default) or simple mode (fallback)
     const useAgenticMode = process.env.LORE_RESEARCH_MODE !== 'simple';
     if (useAgenticMode) {
         console.error('[research] Using agentic mode (Claude Agent SDK)');
+        await onProgress?.(0, undefined, 'Starting agentic research...');
         try {
-            const result = await runResearchAgent(dbPath, dataDir, args);
+            const result = await runResearchAgent(dbPath, dataDir, args, onProgress);
+            await onProgress?.(100, 100, 'Research complete');
             await runResearchCompletedHook(result, {
                 mode: options.hookContext?.mode || 'mcp',
                 dataDir,
@@ -124,11 +259,14 @@ export async function handleResearch(dbPath, dataDir, args, options = {}) {
         }
         catch (error) {
             console.error('[research] Agentic mode failed, falling back to simple mode:', error);
+            await onProgress?.(0, undefined, 'Agentic mode failed, falling back to simple mode...');
             // Fall through to simple mode
         }
     }
     console.error('[research] Using simple mode (single-pass synthesis)');
-    const result = await handleResearchSimple(dbPath, dataDir, args);
+    await onProgress?.(0, undefined, 'Starting simple research...');
+    const result = await handleResearchSimple(dbPath, dataDir, args, onProgress);
+    await onProgress?.(100, 100, 'Research complete');
     await runResearchCompletedHook(result, {
         mode: options.hookContext?.mode || 'mcp',
         dataDir,
@@ -140,7 +278,7 @@ export async function handleResearch(dbPath, dataDir, args, options = {}) {
  * Simple research mode - single pass search + synthesis
  * This is the fallback when agentic mode fails or is disabled
  */
-async function handleResearchSimple(dbPath, dataDir, args) {
+async function handleResearchSimple(dbPath, dataDir, args, onProgress) {
     const { task, project, include_sources = true } = args;
     // Use sensible defaults for simple mode
     const sourceLimit = 10;
@@ -149,7 +287,9 @@ async function handleResearchSimple(dbPath, dataDir, args) {
     const archivedProjects = await loadArchivedProjects(dataDir);
     const archivedNames = new Set(archivedProjects.map((p) => p.project.toLowerCase()));
     // Step 1: Search for relevant sources (fetch extra to account for archived filtering)
+    await onProgress?.(10, 100, 'Generating embeddings...');
     const queryVector = await generateEmbedding(task);
+    await onProgress?.(30, 100, 'Searching sources...');
     const rawSources = await searchSources(dbPath, queryVector, {
         limit: sourceLimit * 2,
         project,
@@ -172,6 +312,7 @@ async function handleResearchSimple(dbPath, dataDir, args) {
         }
     }
     // Step 3: Synthesize findings with LLM (conflict-aware)
+    await onProgress?.(60, 100, 'Synthesizing findings...');
     // Note: Decisions are now extracted at query time by the agentic research mode
     const synthesis = await synthesizeFindings(task, sources.map((s) => ({
         id: s.id,

package/dist/mcp/handlers/sync.d.ts

@@ -38,10 +38,12 @@ interface SyncResult {
         errors: number;
         titles: string[];
     };
+    reconciled: number;
 }
 export declare function handleSync(dbPath: string, dataDir: string, args: SyncArgs, options?: {
     hookContext?: {
         mode: 'mcp' | 'cli';
     };
+    onProgress?: (progress: number, total?: number, message?: string) => Promise<void>;
 }): Promise<SyncResult>;
 export {};