olympus-ai 4.0.4 → 4.1.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "olympus-ai",
-  "version": "4.0.4",
+  "version": "4.1.1",
   "description": "Olympus: Multi-agent orchestration for Claude Code. Summon the gods of code.",
   "author": {
     "name": "mikev10",

package/README.md

@@ -111,27 +111,37 @@ claude
 
 ## Installation
 
+### Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/claude-code) installed
+- Node.js 20+ (`node -v` to check)
+
 ### Global Installation (Recommended)
 
-Install Olympus globally to use across all projects:
+Install Olympus globally to enable it across all your projects:
 
 ```bash
 npm install -g olympus-ai
 olympus-ai install
 ```
 
-This installs agents, skills, rules, and hooks to `~/.claude/`.
+This installs agents, skills, rules, and hooks to `~/.claude/` so every Claude Code session has access to Olympus.
 
 ### Local Project Installation
 
-Install Olympus for a specific project only:
+Install Olympus as a dev dependency for a specific project. This is useful for teams that want Olympus pinned to a specific version in their repo:
 
 ```bash
-npm install -g olympus-ai
-olympus-ai install --local
+# Install as a dev dependency
+npm install --save-dev olympus-ai
+
+# Run the installer for this project only
+npx olympus-ai install --local
 ```
 
-This installs to `./.claude/` in your current project directory.
+This installs agents, skills, rules, hooks, and settings to `./.claude/` in your current project directory.
+
+> **Note:** You can use both. A global install provides Olympus across all projects, while a local install scopes everything to the current project. Local files take precedence over global ones.
 
 ---
 
@@ -600,17 +610,68 @@ This is a TypeScript monorepo using:
 
 ## Uninstall
 
+Olympus provides a safe uninstall that **only removes Olympus-owned files** — your own Claude Code agents, skills, hooks, and CLAUDE.md content are preserved.
+
+### Quick Uninstall (One Command)
+
+For global installations, a single npm command handles everything — the `preuninstall` hook automatically cleans up Olympus config files before removing the package:
+
+```bash
+npm uninstall -g olympus-ai
+```
+
+For local project installations:
+
+```bash
+npm uninstall olympus-ai
+```
+
+> **Note:** Local `npm uninstall` removes the package dependency but does not clean up `.claude/` config files. Run `npx olympus-ai uninstall --local` first if you need to remove those, or see the manual steps below.
+
+### Manual Uninstall
+
+If you prefer more control, or need to remove config files without uninstalling the package:
+
 ```bash
-# Remove agents and skills
-rm -rf ~/.claude/agents ~/.claude/skills ~/.claude/hooks ~/.claude/olympus ~/.claude/CLAUDE.md
+# Remove Olympus config files from ~/.claude/ (global)
+olympus-ai uninstall
+
+# Remove Olympus config files from ./.claude/ (current project)
+olympus-ai uninstall --local
+
+# Preview what would be removed without deleting anything
+olympus-ai uninstall --dry-run
 ```
 
+Then remove the npm package:
+
+```bash
+# Global
+npm uninstall -g olympus-ai
+
+# Local
+npm uninstall olympus-ai
+```
+
+### What Gets Removed
+
+The uninstall command removes only files that Olympus installed:
+- Olympus agent definitions from `agents/` (e.g., `oracle.md`, `prometheus.md`)
+- Olympus skill directories from `skills/` (e.g., `ultrawork/`, `plan/`)
+- The `olympus/` directory (rules, learning data)
+- Olympus hook scripts from `hooks/`
+- Olympus hook entries from `settings.json`
+- The Olympus section from `CLAUDE.md` (user content is preserved)
+- The `.olympus-version.json` metadata file
+- The Olympus plugin registration
+
+Any custom agents, skills, hooks, or CLAUDE.md content you added yourself will **not** be touched.
+
 ---
 
 ## Requirements
 
-- [Claude Code](https://docs.anthropic.com/claude-code) installed
-- Anthropic API key (`ANTHROPIC_API_KEY` environment variable)
+- [Claude Code](https://docs.anthropic.com/claude-code) installed and configured
 - Node.js 20+ (for npm installation)
 
 ---

package/dist/cli/index.js

@@ -12,13 +12,13 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { loadConfig, getConfigPaths, generateConfigSchema } from '../config/loader.js';
 import { createOlympusSession } from '../index.js';
 import { checkForUpdates, performUpdate, formatUpdateNotification, getInstalledVersion } from '../features/auto-update.js';
-import { install as installOlympus, isInstalled, getInstallInfo } from '../installer/index.js';
-import { readFeedbackLog, readJsonFile, getLearningDir, writeJsonFile, appendFeedback, updateAgentPerformance, loadSessionSummaries, getLastSessionSummary, } from '../learning/storage.js';
+import { install as installOlympus, uninstall as uninstallOlympus, isInstalled, getInstallInfo } from '../installer/index.js';
+import { readFeedbackLog, readJsonFile, getLearningDir, writeJsonFile, appendFeedback, updateAgentPerformance, loadSessionSummaries, readAgentPerformance, } from '../learning/storage.js';
 import { extractPatterns } from '../learning/pattern-extractor.js';
 import { extractPatterns as extractTaskPatterns, computePatternConfidence } from '../learning/pattern-matcher.js';
 import { updatePreferences, createDefaultPreferences } from '../learning/preference-learner.js';
@@ -27,13 +27,14 @@ import { generatePromptPatches, previewPatches, applyPromptPatches } from '../le
 import { readDiscoveries, recordDiscovery } from '../learning/discovery.js';
 import { migrateNotepads } from '../learning/migrate-notepads.js';
 import { generateLearningStats, formatLearningStats } from '../learning/stats.js';
-import { cleanupLearning, formatCleanupResult } from '../learning/cleanup.js';
+import { cleanupLearning, formatCleanupResult, collectProjectDirStats } from '../learning/cleanup.js';
+import { resolveProjectRoot, deriveProjectSlug, getProjectScopedDir } from '../learning/project-resolver.js';
 import { getWarningThreshold } from '../learning/baselines.js';
 import { calculateCost, DEFAULT_PRICING } from '../learning/pricing.js';
 import { getTokenUsage, hasEfficiencyMetrics, safeTokenTotal } from '../learning/utils.js';
 import { getSessionStatePath } from '../learning/session-state.js';
 import { randomUUID } from 'crypto';
-import { rmSync, appendFileSync } from 'fs';
+import { rmSync, appendFileSync, readdirSync, statSync } from 'fs';
 import { showMetrics, exportMetrics, analyzeMetrics, cleanMetrics } from './commands/metrics.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Try to load package.json for version
@@ -496,9 +497,48 @@ program
         process.exit(1);
     }
 });
-/**
- * Postinstall command - Silent install for npm postinstall hook
- */
+program
+    .command('uninstall')
+    .description('Uninstall Olympus files (only removes Olympus-owned files)')
+    .option('--local', 'Uninstall from current project (./.claude/) instead of global (~/.claude/)')
+    .option('--dry-run', 'Show what would be removed without actually removing')
+    .option('-v, --verbose', 'Show detailed output')
+    .action((opts) => {
+    const prefix = opts.dryRun ? chalk.yellow('[DRY RUN] ') : '';
+    console.log(chalk.blue(`${prefix}Uninstalling Olympus...`));
+    console.log('');
+    const result = uninstallOlympus({
+        local: opts.local,
+        dryRun: opts.dryRun,
+        verbose: opts.verbose || opts.dryRun
+    });
+    if (result.errors.length > 0) {
+        result.errors.forEach(err => console.error(chalk.red(`  Error: ${err}`)));
+        console.log('');
+    }
+    if (opts.dryRun) {
+        console.log(chalk.yellow(`Would remove ${result.removedFiles.length} file(s)/directories.`));
+        console.log(chalk.gray('Run without --dry-run to apply.'));
+    }
+    else {
+        if (result.success) {
+            console.log(chalk.green(`Removed ${result.removedFiles.length} file(s)/directories. Olympus has been uninstalled.`));
+        }
+        else {
+            console.log(chalk.yellow(`Removed ${result.removedFiles.length} file(s)/directories (with ${result.errors.length} error(s)).`));
+        }
+        console.log('');
+        if (opts.local) {
+            console.log(chalk.gray('To also remove the npm package: npm uninstall olympus-ai'));
+        }
+        else {
+            console.log(chalk.gray('To also remove the npm package: npm uninstall -g olympus-ai'));
+        }
+    }
+    if (!result.success) {
+        process.exit(1);
+    }
+});
 program
     .command('postinstall', { hidden: true })
     .description('Run post-install setup (called automatically by npm)')
@@ -535,18 +575,72 @@ program
     .option('--suggest', 'Show suggested prompt improvements')
     .option('--apply', 'Apply suggested improvements')
     .option('-f, --forget', 'Forget all learnings')
-    .option('-p, --project', 'Scope to current project (with --forget)')
-    .option('-e, --export', 'Export learnings to JSON')
+    .option('-p, --project [slug]', 'Project slug for --forget; omit value to use current project')
+    .option('-e, --export [file]', 'Export current project data to file or stdout')
     .option('-i, --import <file>', 'Import learnings from JSON')
     .option('--efficiency', 'Show agent efficiency rankings and token metrics')
     .option('--show-costs', 'Show cost breakdown by model and agent')
     .option('--budget-status', 'Show current session token budget status')
     .option('--last-session', 'Show last session summary')
     .option('--sessions [n]', 'Show last N sessions (default: 10)')
+    .option('--global', 'Show global learning data, bypassing project scoping')
+    .option('--all-projects', 'List all project directories with stats')
+    .option('--confirm', 'Confirm destructive operations (required for --forget)')
     .action(async (options) => {
     const learningDir = getLearningDir();
+    function resolveProjectContext() {
+        if (options.global) {
+            return { projectPath: null, isInProject: false };
+        }
+        try {
+            const resolved = resolveProjectRoot(process.cwd());
+            const cwd = resolve(process.cwd());
+            if (resolved === cwd) {
+                return { projectPath: null, isInProject: false };
+            }
+            return { projectPath: resolved, isInProject: true };
+        }
+        catch {
+            return { projectPath: null, isInProject: false };
+        }
+    }
+    if (options.allProjects) {
+        try {
+            const projectsDir = join(getLearningDir(), 'projects');
+            const stats = collectProjectDirStats(projectsDir);
+            if (stats.length === 0) {
+                console.log('No project directories found.');
+                return;
+            }
+            const slugW = 40, dateW = 22, sizeW = 10, feedW = 10, sessW = 8;
+            const header = 'Project'.padEnd(slugW) + 'Last Modified'.padEnd(dateW) + 'Size'.padStart(sizeW) + 'Feedback'.padStart(feedW) + 'Sessions'.padStart(sessW);
+            const divider = '-'.repeat(slugW + dateW + sizeW + feedW + sessW);
+            console.log(header);
+            console.log(divider);
+            for (const s of stats) {
+                const sizeKb = (s.sizeBytes / 1024).toFixed(0) + ' KB';
+                const dateStr = s.lastModified.toISOString().replace('T', ' ').substring(0, 16);
+                const line = s.slug.substring(0, slugW).padEnd(slugW)
+                    + dateStr.padEnd(dateW)
+                    + sizeKb.padStart(sizeW)
+                    + String(s.feedbackCount).padStart(feedW)
+                    + String(s.sessionCount).padStart(sessW);
+                console.log(line);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[Olympus] Failed to list project directories: ${msg}`);
+        }
+        return;
+    }
     if (options.lastSession) {
-        const summary = getLastSessionSummary();
+        const { projectPath: lsProjectPath } = resolveProjectContext();
+        if (!lsProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
+        const lsSummaries = loadSessionSummaries(lsProjectPath ?? undefined);
+        const summary = lsSummaries.length > 0 ? lsSummaries[lsSummaries.length - 1] : null;
         if (!summary) {
             console.log(chalk.yellow('No session summaries recorded yet. Complete a session first.'));
             return;
@@ -576,9 +670,13 @@ program
         return;
     }
     if (options.sessions !== undefined) {
+        const { projectPath: sessProjectPath } = resolveProjectContext();
+        if (!sessProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
         const n = typeof options.sessions === 'string' ? parseInt(options.sessions) : 10;
         const count = isNaN(n) ? 10 : n;
-        const allSummaries = loadSessionSummaries();
+        const allSummaries = loadSessionSummaries(sessProjectPath ?? undefined);
         if (allSummaries.length === 0) {
             console.log(chalk.yellow('No session summaries recorded yet. Complete a session first.'));
             return;
@@ -630,6 +728,24 @@ program
     if (options.stats) {
         const stats = generateLearningStats(process.cwd());
         console.log(formatLearningStats(stats));
+        try {
+            const projectsDir = join(getLearningDir(), 'projects');
+            const projStats = collectProjectDirStats(projectsDir);
+            if (projStats.length > 0) {
+                console.log('\nPer-Project Storage:');
+                let totalBytes = 0;
+                for (const ps of projStats) {
+                    const sizeKb = (ps.sizeBytes / 1024).toFixed(0) + ' KB';
+                    console.log(`  ${ps.slug.padEnd(40)} ${sizeKb.padStart(8)}`);
+                    totalBytes += ps.sizeBytes;
+                }
+                const totalKb = (totalBytes / 1024).toFixed(0) + ' KB';
+                console.log(`  ${'-'.repeat(49)}`);
+                console.log(`  Total (${projStats.length} project${projStats.length === 1 ? '' : 's'}):${' '.repeat(Math.max(0, 33 - String(projStats.length).length - 10))} ${totalKb.padStart(8)}`);
+                console.log(`\nGlobal learning directory: ${getLearningDir()} (${totalKb})`);
+            }
+        }
+        catch { }
         return;
     }
     if (options.cleanup) {
@@ -643,10 +759,14 @@ program
         return;
     }
     if (options.show) {
+        const { projectPath: showProjectPath, isInProject: showIsInProject } = resolveProjectContext();
+        if (!showIsInProject && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
         console.log(chalk.blue.bold('\n╭─────────────────────────────────────────────────────────────╮'));
         console.log(chalk.blue.bold('│                  OLYMPUS LEARNING STATUS                    │'));
         console.log(chalk.blue.bold('╰─────────────────────────────────────────────────────────────╯\n'));
-        const feedback = readFeedbackLog();
+        const feedback = readFeedbackLog(showProjectPath ?? undefined);
         const revisions = feedback.filter(f => f.event_type === 'revision').length;
         const cancellations = feedback.filter(f => f.event_type === 'cancellation').length;
         const successes = feedback.filter(f => f.event_type === 'success').length;
@@ -659,8 +779,18 @@ program
                 console.log(`   • Verbosity: ${prefs.verbosity}`);
             if (prefs.autonomy !== 'unknown')
                 console.log(`   • Autonomy: ${prefs.autonomy}`);
-            for (const rule of prefs.explicit_rules.slice(0, 3)) {
-                console.log(`   • ${rule}`);
+            const filteredRules = prefs.explicit_rules.filter((r) => {
+                if (typeof r === 'object' && r !== null && 'rule' in r) {
+                    const rObj = r;
+                    return !showProjectPath || !rObj.project_path || rObj.project_path === showProjectPath;
+                }
+                return true;
+            });
+            for (const rule of filteredRules.slice(0, 3)) {
+                const ruleText = typeof rule === 'object' && rule !== null && 'rule' in rule
+                    ? rule.rule
+                    : String(rule);
+                console.log(`   * ${ruleText}`);
             }
             console.log('');
         }
@@ -671,7 +801,7 @@ program
             }
             console.log('');
         }
-        const agentPerf = readJsonFile(join(learningDir, 'agent-performance.json'), {});
+        const agentPerf = readAgentPerformance(showProjectPath ?? undefined);
         if (Object.keys(agentPerf).length > 0) {
             console.log(chalk.white('🤖 Agent Performance:'));
             for (const [name, perf] of Object.entries(agentPerf)) {
@@ -680,7 +810,16 @@ program
             }
             console.log('');
         }
-        // Show discoveries
+        const showSummaries = loadSessionSummaries(showProjectPath ?? undefined);
+        if (showSummaries.length > 0) {
+            console.log(chalk.white('📅 Sessions:'));
+            console.log(`   • Total recorded: ${showSummaries.length}`);
+            const lastS = showSummaries[showSummaries.length - 1];
+            if (lastS) {
+                console.log(`   • Last: ${new Date(lastS.started_at).toLocaleString()}`);
+            }
+            console.log('');
+        }
         const discoveries = readDiscoveries(process.cwd());
         if (discoveries.total_discoveries > 0) {
             console.log(chalk.white('💡 Discoveries:'));
@@ -695,7 +834,6 @@ program
             }
             console.log('');
         }
-        // Show auto-discovery configuration status
         try {
             const { loadDiscoveryConfig } = await import('../learning/config.js');
             const discoveryConfig = loadDiscoveryConfig(process.cwd());
@@ -704,7 +842,6 @@ program
             console.log(`   • Min Confidence: ${discoveryConfig.minConfidence}`);
             console.log(`   • Limits: ${discoveryConfig.maxPerSession}/session, ${discoveryConfig.maxPerDay}/day`);
             console.log(`   • Dedup Window: ${discoveryConfig.deduplicationWindowDays} days`);
-            // Show recent auto-discoveries with confidence scores
             if (discoveries.total_discoveries > 0) {
                 const recentAuto = [...discoveries.project_discoveries]
                     .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
@@ -721,29 +858,31 @@ program
             console.log('');
         }
         catch {
-            // Silent failure - auto-discovery status is non-critical
         }
         return;
     }
     if (options.analyze) {
+        const { projectPath: analyzeProjectPath } = resolveProjectContext();
+        if (!analyzeProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
         console.log(chalk.blue('Analyzing feedback...\n'));
-        const feedback = readFeedbackLog();
-        const patterns = extractPatterns(feedback);
+        const feedback = readFeedbackLog(analyzeProjectPath ?? undefined);
+        const patterns = extractPatterns(feedback, undefined, undefined, analyzeProjectPath ?? undefined);
         console.log(chalk.white(`Found ${patterns.length} patterns:\n`));
         for (const p of patterns) {
             console.log(`  [${(p.confidence * 100).toFixed(0)}%] ${p.pattern.substring(0, 60)}...`);
             console.log(chalk.gray(`       Seen ${p.evidence_count}x, scope: ${p.scope}, category: ${p.category}`));
         }
-        // Update preferences
         const currentPrefs = readJsonFile(join(learningDir, 'user-preferences.json'), createDefaultPreferences());
-        const updatedPrefs = updatePreferences(currentPrefs, feedback, patterns);
+        const updatedPrefs = updatePreferences(currentPrefs, feedback, patterns, analyzeProjectPath ?? undefined);
         writeJsonFile(join(learningDir, 'user-preferences.json'), updatedPrefs);
-        // Update agent performance
         const agentPerf = evaluateAgentPerformance(feedback);
-        // Extract task patterns for routing recommendations
         const agentPerfObj = Object.fromEntries(agentPerf);
-        // Load existing performance to preserve existing task_patterns
-        const existingPerf = readJsonFile(join(learningDir, 'agent-performance.json'), {});
+        const agentPerfWritePath = analyzeProjectPath
+            ? join(getProjectScopedDir(analyzeProjectPath), 'agent-performance.json')
+            : join(learningDir, 'agent-performance.json');
+        const existingPerf = readJsonFile(agentPerfWritePath, {});
         // Analyze task patterns per agent
         for (const [agentName, perf] of Object.entries(agentPerfObj)) {
             const agentFeedback = feedback.filter(f => f.agent_used === agentName);
@@ -776,15 +915,13 @@ program
                 });
             }
             if (taskPatterns.length > 0) {
-                perf.task_patterns = taskPatterns.slice(0, 10); // Limit to top 10 patterns
+                perf.task_patterns = taskPatterns.slice(0, 10);
             }
             else if (existingPerf[agentName]?.task_patterns) {
-                // Preserve existing patterns if no new ones found
                 perf.task_patterns = existingPerf[agentName].task_patterns;
             }
         }
-        // Write with patterns included
-        writeJsonFile(join(learningDir, 'agent-performance.json'), agentPerfObj);
+        writeJsonFile(agentPerfWritePath, agentPerfObj);
         const totalPatterns = Object.values(agentPerfObj).reduce((sum, p) => sum + (p.task_patterns?.length || 0), 0);
         if (totalPatterns > 0) {
             console.log(chalk.green(`✓ ${totalPatterns} task patterns extracted for routing optimization.`));
@@ -828,19 +965,42 @@ program
     }
     if (options.forget) {
         if (options.project) {
-            const projectDir = join(process.cwd(), '.olympus', 'learning');
-            if (existsSync(projectDir)) {
-                rmSync(projectDir, { recursive: true });
-                console.log(chalk.green('✓ Project learnings forgotten.'));
-            }
-            else {
-                console.log(chalk.yellow('No project learnings found.'));
+            try {
+                const targetSlug = typeof options.project === 'string'
+                    ? options.project
+                    : deriveProjectSlug(resolveProjectRoot(process.cwd()));
+                const targetPath = join(getLearningDir(), 'projects', targetSlug);
+                if (!options.confirm) {
+                    if (!existsSync(targetPath)) {
+                        console.log(`Project directory not found: ${targetSlug}`);
+                        return;
+                    }
+                    const files = readdirSync(targetPath);
+                    console.log(`Would delete: ${targetPath}`);
+                    for (const f of files) {
+                        const fp = join(targetPath, f);
+                        let sz = 0;
+                        try {
+                            sz = statSync(fp).size;
+                        }
+                        catch { }
+                        console.log(`  ${f} (${sz} bytes)`);
+                    }
+                    console.log('Run with --confirm to delete.');
+                }
+                else {
+                    if (!existsSync(targetPath)) {
+                        console.log(`Project directory not found: ${targetSlug}`);
+                        return;
+                    }
+                    const fileCount = readdirSync(targetPath).length;
+                    rmSync(targetPath, { recursive: true, force: true });
+                    console.log(chalk.green(`Deleted project data for ${targetSlug} (${fileCount} files removed).`));
+                }
             }
-            // DELETE SESSION STATE (privacy fix)
-            const sessionStatePath = getSessionStatePath(process.cwd());
-            if (existsSync(sessionStatePath)) {
-                rmSync(sessionStatePath);
-                console.log(chalk.green('✓ Session state deleted.'));
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[Olympus] Failed to forget project: ${msg}`);
             }
         }
         else {
@@ -855,15 +1015,35 @@ program
         }
         return;
     }
-    if (options.export) {
-        const data = {
-            feedback: readFeedbackLog(),
-            preferences: readJsonFile(join(learningDir, 'user-preferences.json'), null),
-            agentPerformance: readJsonFile(join(learningDir, 'agent-performance.json'), {}),
-            discoveries: readDiscoveries(process.cwd()),
-            exportedAt: new Date().toISOString(),
-        };
-        console.log(JSON.stringify(data, null, 2));
+    if (options.export !== undefined) {
+        try {
+            const { projectPath: exportProjectPath, isInProject: exportIsInProject } = resolveProjectContext();
+            if (!exportIsInProject) {
+                console.log('Not inside a recognized project directory. Showing global data.');
+                return;
+            }
+            const exportProjDir = getProjectScopedDir(exportProjectPath);
+            const readRaw = (file) => {
+                const p = join(exportProjDir, file);
+                return existsSync(p) ? readFileSync(p, 'utf-8') : null;
+            };
+            const output = JSON.stringify({
+                feedback_log: readRaw('feedback-log.jsonl'),
+                agent_performance: readRaw('agent-performance.json'),
+                session_insights: readRaw('session-insights.json'),
+            }, null, 2);
+            if (typeof options.export === 'string' && options.export.length > 0) {
+                writeFileSync(options.export, output, 'utf-8');
+                console.log(chalk.green(`✓ Exported to ${options.export}`));
+            }
+            else {
+                console.log(output);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[Olympus] Failed to export: ${msg}`);
+        }
         return;
     }
     if (options.import) {
@@ -893,9 +1073,12 @@ program
         return;
     }
     if (options.efficiency) {
-        const feedback = readFeedbackLog();
-        const agentPerfRaw = readJsonFile(join(learningDir, 'agent-performance.json'), {});
-        // Compute agent performance from feedback if not already computed
+        const { projectPath: effProjectPath } = resolveProjectContext();
+        if (!effProjectPath && !options.global) {
+            console.log('Not inside a recognized project directory. Showing global data.');
+        }
+        const feedback = readFeedbackLog(effProjectPath ?? undefined);
+        const agentPerfRaw = readAgentPerformance(effProjectPath ?? undefined);
         const agentPerf = {};
         const agentNames = new Set(feedback.filter(f => f.agent_used).map(f => f.agent_used));
         for (const agentName of agentNames) {
@@ -904,7 +1087,6 @@ program
                 agentPerf[agentName] = perf;
             }
         }
-        // Merge with existing performance data
         Object.assign(agentPerf, agentPerfRaw);
         const agents = Object.values(agentPerf).filter(p => hasEfficiencyMetrics(p));
         if (agents.length === 0) {