@magic-ingredients/tiny-brain-local 0.20.1 → 0.21.1

package/dist/storage/local-filesystem-adapter.js

@@ -125,9 +125,6 @@ export class LocalFilesystemStorageAdapter {
         const personaDir = this.pathBuilder.buildPersonaDirectoryPath(personaId);
         // Create main persona directory
         await this.ensureDirectoryExists(personaDir);
-        // Create plans subdirectory
-        const plansDir = join(personaDir, 'plans');
-        await this.ensureDirectoryExists(plansDir);
     }
     async storeUserData(key, content, _userId) {
         const filePath = this.pathBuilder.buildUserDataPath(key);

package/dist/tools/dashboard/dashboard.tool.d.ts

@@ -2,10 +2,11 @@ import { type ToolArguments, type ToolResult } from '../index.js';
 import type { RequestContext } from '../../types/request-context.js';
 import type { Tool as MCPTool } from '@modelcontextprotocol/sdk/types.js';
 /**
- * Dashboard Tool - Restart the dashboard server
+ * Dashboard Tool - Rebuild and restart the dashboard server
  *
- * Developer maintenance tool for force-reloading the dashboard,
- * e.g. after rebuilding packages.
+ * Developer maintenance tool that runs `npm run rebuild_all` to rebuild
+ * all packages and rebundle the plugin, then kills the old dashboard
+ * process on port 8765 and restarts from the fresh bundle.
  */
 export declare class DashboardTool {
     static getToolDefinition(): MCPTool;

package/dist/tools/dashboard/dashboard.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dashboard.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/dashboard/dashboard.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,OAAO,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE1E;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,MAAM,CAAC,iBAAiB,IAAI,OAAO;WAatB,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;CAiBzF"}
+{"version":3,"file":"dashboard.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/dashboard/dashboard.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAA0C,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,OAAO,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE1E;;;;;;GAMG;AACH,qBAAa,aAAa;IACxB,MAAM,CAAC,iBAAiB,IAAI,OAAO;WAatB,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;CA8DzF"}

package/dist/tools/dashboard/dashboard.tool.js

@@ -1,9 +1,11 @@
+import { execSync } from 'node:child_process';
 import { createErrorResult, createSuccessResult } from '../index.js';
 /**
- * Dashboard Tool - Restart the dashboard server
+ * Dashboard Tool - Rebuild and restart the dashboard server
  *
- * Developer maintenance tool for force-reloading the dashboard,
- * e.g. after rebuilding packages.
+ * Developer maintenance tool that runs `npm run rebuild_all` to rebuild
+ * all packages and rebundle the plugin, then kills the old dashboard
+ * process on port 8765 and restarts from the fresh bundle.
  */
 export class DashboardTool {
     static getToolDefinition() {
@@ -23,12 +25,57 @@ export class DashboardTool {
         if (!launcher) {
             return createErrorResult('Dashboard launcher is not available. The dashboard may not have been started.');
         }
+        // Find the repo root (where package.json with rebuild_all lives)
+        let repoRoot;
         try {
-            const result = await launcher.restart(context, {});
-            return createSuccessResult(`Dashboard restarted successfully at ${result.url}`);
+            repoRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+        }
+        catch {
+            return createErrorResult('Could not determine repository root. Are you in a git repository?');
+        }
+        // Step 1: Rebuild all packages
+        const steps = [];
+        try {
+            execSync('npm run rebuild_all', {
+                cwd: repoRoot,
+                encoding: 'utf-8',
+                stdio: 'pipe',
+                timeout: 120_000,
+            });
+            steps.push('Rebuilt all packages (rebuild_all)');
         }
         catch (error) {
-            return createErrorResult(`Failed to restart dashboard: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return createErrorResult(`rebuild_all failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Step 2: Stop the current dashboard and kill the port
+        try {
+            await launcher.stop();
+            steps.push('Stopped dashboard server');
+        }
+        catch {
+            // Ignore stop errors — port kill will clean up
+        }
+        try {
+            execSync('lsof -ti:8765 | xargs kill 2>/dev/null || true', {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            steps.push('Killed process on port 8765');
+        }
+        catch {
+            // No process on port — fine
+        }
+        // Step 3: Start fresh from the new bundle
+        try {
+            const result = await launcher.restart(context, {});
+            steps.push(`Dashboard started at ${result.url}`);
+            return createSuccessResult(steps.join('\n'));
+        }
+        catch {
+            // In-process restart failed (expected — bundle is stale in memory)
+            // The rebuild is done, user needs to restart the MCP server
+            steps.push('Note: MCP server must be restarted for code changes to take effect (the running process still has the old bundle in memory)');
+            return createSuccessResult(steps.join('\n'));
         }
     }
 }

package/dist/tools/plan/plan.tool.d.ts

@@ -11,7 +11,6 @@ export declare class PlanTool {
     private static handleStatus;
     private static handleReport;
     private static handleList;
-    private static handleArchive;
     private static handleStartDashboard;
     private static handleStopDashboard;
     private static handleDashboardStatus;

package/dist/tools/plan/plan.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/plan/plan.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AA2LrE,qBAAa,QAAQ;IACnB,MAAM,CAAC,iBAAiB,IAAI,OAAO;WA4LtB,OAAO,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC;mBA2ED,YAAY;mBA+LZ,aAAa;mBAyCb,eAAe;mBA0Df,YAAY;mBA+CZ,YAAY;mBAsDZ,YAAY;mBAiCZ,UAAU;mBA2DV,aAAa;mBA2Cb,oBAAoB;mBA+CpB,mBAAmB;mBAsBnB,qBAAqB;mBAqCrB,SAAS;mBAgGT,eAAe;IAuFpC;;OAEG;mBACkB,UAAU;CA2DhC"}
+{"version":3,"file":"plan.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/plan/plan.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAsLrE,qBAAa,QAAQ;IACnB,MAAM,CAAC,iBAAiB,IAAI,OAAO;WAgLtB,OAAO,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC;mBAyED,YAAY;mBA+LZ,aAAa;mBAyCb,eAAe;mBA0Df,YAAY;mBA+CZ,YAAY;mBAsDZ,YAAY;mBAiCZ,UAAU;mBA2DV,oBAAoB;mBA+CpB,mBAAmB;mBAsBnB,qBAAqB;mBAqCrB,SAAS;mBAgGT,eAAe;IAuFpC;;OAEG;mBACkB,UAAU;CA2DhC"}

package/dist/tools/plan/plan.tool.js

@@ -9,7 +9,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
 const PlanArgsSchema = z.object({
-    operation: z.enum(['accept', 'feature', 'implement', 'update', 'status', 'report', 'list', 'archive', 'adr', 'create-adr', 'sync', 'start-dashboard', 'stop-dashboard', 'dashboard-status']),
+    operation: z.enum(['accept', 'feature', 'implement', 'update', 'status', 'report', 'list', 'adr', 'create-adr', 'sync', 'start-dashboard', 'stop-dashboard', 'dashboard-status']),
     // For 'accept' operation
     planName: z.string().optional(),
     planDetails: z.string().optional(),
@@ -39,12 +39,12 @@ const PlanArgsSchema = z.object({
         updateFeature: z
             .object({
             featureNumber: z.number(),
-            status: z.enum(['defined', 'tested', 'completed']).optional(),
+            status: z.enum(['not_started', 'in_progress', 'completed', 'superseded']).optional(),
             addTask: z.string().optional(),
             addTasks: z.array(z.string()).optional(),
             updateTask: z.object({
                 id: z.string(),
-                status: z.enum(['defined', 'tested', 'completed']).optional(),
+                status: z.enum(['not_started', 'in_progress', 'completed', 'superseded']).optional(),
                 testCommitSha: z.string().optional(),
                 testCommittedAt: z.string().optional(),
                 commitSha: z.string().optional(),
@@ -58,7 +58,7 @@ const PlanArgsSchema = z.object({
         updateFeatures: z
             .array(z.object({
             featureNumber: z.number(),
-            status: z.enum(['defined', 'tested', 'completed']).optional(),
+            status: z.enum(['not_started', 'in_progress', 'completed', 'superseded']).optional(),
             addTask: z.string().optional(),
             addTasks: z.array(z.string()).optional(),
         }))
@@ -71,11 +71,6 @@ const PlanArgsSchema = z.object({
     saveToFile: z.boolean().optional(),
     // For 'list' operation
     listStatus: z.enum(['active', 'completed', 'archived', 'all']).optional(),
-    // For 'archive' operation
-    reason: z.string().optional(),
-    // For 'switch' operation
-    // planId is reused from update operation
-    // Note: switchToPlan automatically unarchives if needed
     // For 'watch' operation
     port: z.number().optional().default(8765),
     autoOpen: z.boolean().optional().default(true),
@@ -190,7 +185,6 @@ export class PlanTool {
   • status: Show current plan progress and summary
   • report: Generate and display comprehensive markdown report
   • list: List all plans (active, completed, archived)
-  • archive: Archive a completed plan
   • adr: Analyze recent commits for ADR suggestions and prompt for creation
   • create-adr: Create ADR file from suggestion (used after user confirmation)
   • start-dashboard: Manually start the dashboard (usually auto-started)
@@ -236,7 +230,7 @@ export class PlanTool {
                 properties: {
                     operation: {
                         type: 'string',
-                        enum: ['accept', 'feature', 'implement', 'update', 'status', 'report', 'list', 'archive', 'adr', 'create-adr', 'start-dashboard', 'stop-dashboard', 'dashboard-status'],
+                        enum: ['accept', 'feature', 'implement', 'update', 'status', 'report', 'list', 'adr', 'create-adr', 'start-dashboard', 'stop-dashboard', 'dashboard-status'],
                         description: 'The planning operation to perform',
                     },
                     // For 'accept' operation
@@ -294,13 +288,13 @@ export class PlanTool {
                                 type: 'object',
                                 properties: {
                                     featureNumber: { type: 'number' },
-                                    status: { type: 'string', enum: ['defined', 'tested', 'completed'] },
+                                    status: { type: 'string', enum: ['not_started', 'in_progress', 'completed', 'superseded'] },
                                     addTask: { type: 'string' },
                                     updateTask: {
                                         type: 'object',
                                         properties: {
                                             id: { type: 'string' },
-                                            status: { type: 'string', enum: ['defined', 'tested', 'completed'] },
+                                            status: { type: 'string', enum: ['not_started', 'in_progress', 'completed', 'superseded'] },
                                             testCommitSha: { type: 'string' },
                                             testCommittedAt: { type: 'string' },
                                             commitSha: { type: 'string' },
@@ -330,17 +324,6 @@ export class PlanTool {
                         enum: ['active', 'completed', 'archived', 'all'],
                         description: 'Filter plans by status',
                     },
-                    // For 'archive' operation
-                    reason: {
-                        type: 'string',
-                        description: 'Reason for archiving',
-                    },
-                    // For 'switch' operation
-                    // planId is reused from update operation
-                    force: {
-                        type: 'boolean',
-                        description: 'Force switch to archived plans (optional)',
-                    },
                     // For 'watch' operation
                     port: {
                         type: 'number',
@@ -400,8 +383,6 @@ export class PlanTool {
                     return await PlanTool.handleReport(validatedArgs, contextWithRepo);
                 case 'list':
                     return await PlanTool.handleList(validatedArgs, contextWithRepo);
-                case 'archive':
-                    return await PlanTool.handleArchive(validatedArgs, contextWithRepo);
                 case 'adr':
                     return await PlanTool.handleAdr(validatedArgs, contextWithRepo);
                 case 'create-adr':
@@ -565,7 +546,7 @@ export class PlanTool {
                             },
                             {
                                 featureNumber: 2,
-                                status: 'tested',
+                                status: 'in_progress',
                                 addTasks: ['New task 1', 'New task 2'],
                             },
                         ],
@@ -640,7 +621,7 @@ export class PlanTool {
                 ...plan.features.map((feature, i) => {
                     const taskCount = feature.tasks?.length || 0;
                     const completedCount = feature.tasks?.filter(t => t.completedAt).length || 0;
-                    const statusEmoji = feature.status === 'completed' ? '✅' : feature.status === 'tested' ? '🔄' : '📋';
+                    const statusEmoji = feature.status === 'completed' ? '✅' : feature.status === 'in_progress' ? '🔄' : '📋';
                     return `${statusEmoji} **Feature ${i + 1}: ${feature.title}** (${completedCount}/${taskCount} tasks complete)`;
                 }),
                 ``,
@@ -805,33 +786,6 @@ export class PlanTool {
             return createErrorResult(`Failed to list plans: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    static async handleArchive(args, context) {
-        try {
-            // planId is required for archive operation
-            if (!args.planId) {
-                return createErrorResult('Plan ID is required for archive operation. Use "plan operation=list" to see available plans.');
-            }
-            // Create service with RequestContext
-            const planningService = new PlanningService(context);
-            // Load the specific plan to archive  
-            const plan = await planningService.loadPlan({ planId: args.planId });
-            if (!plan) {
-                return createErrorResult(`Plan not found: ${args.planId}. Use "plan operation=list" to see available plans.`);
-            }
-            // Archive the plan with explicit args
-            const archived = await planningService.archivePlan({
-                planId: plan.id,
-                reason: args.reason
-            });
-            if (!archived) {
-                return createErrorResult('Failed to archive plan.');
-            }
-            return createSuccessResult(`✅ Archived plan: "${plan.title}"\nReason: ${args.reason || 'Completed'}`);
-        }
-        catch (error) {
-            return createErrorResult(`Failed to archive plan: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
     static async handleStartDashboard(args, context) {
         try {
             // Check if dashboard is already running
@@ -856,7 +810,7 @@ export class PlanTool {
                 '',
                 'The dashboard provides:',
                 '• Real-time plan monitoring',
-                '• Plan management (create, archive, delete)',
+                '• Plan management (create, delete)',
                 '• Persona overview',
                 '• Auto-refresh on changes',
                 '',

package/dist/tools/quality/quality.tool.js

@@ -638,7 +638,7 @@ Persists and retrieves quality analysis results. Analysis is performed by agents
         lines.push('## Next Steps');
         lines.push('');
         for (const fixId of fixIds) {
-            lines.push(`1. Run \`npx tiny-brain sync-file .tiny-brain/fixes/${fixId}.md\``);
+            lines.push(`1. Run \`npx tiny-brain sync-progress .tiny-brain/fixes/${fixId}.md\``);
         }
         lines.push('2. Start working on fixes using the /fix workflow');
         lines.push('3. Track progress in the dashboard');

package/dist/tools/recommendations/recommendations.tool.d.ts

@@ -0,0 +1,13 @@
+import { type ToolResult } from '../index.js';
+import type { RequestContext } from '../../types/request-context.js';
+import { Tool as MCPTool } from '@modelcontextprotocol/sdk/types.js';
+export declare class RecommendationsTool {
+    static getToolDefinition(): MCPTool;
+    static execute(args: Record<string, unknown>, context: RequestContext): Promise<ToolResult>;
+    private static handleList;
+    private static handleAccept;
+    private static handleDismiss;
+    private static handleRestore;
+    private static handleGraduated;
+}
+//# sourceMappingURL=recommendations.tool.d.ts.map

package/dist/tools/recommendations/recommendations.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommendations.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/recommendations/recommendations.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AASrE,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,iBAAiB,IAAI,OAAO;WA8BtB,OAAO,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC;mBAkCD,UAAU;mBAgCV,YAAY;mBAqCZ,aAAa;mBAgCb,aAAa;mBAwCb,eAAe;CAkBrC"}

package/dist/tools/recommendations/recommendations.tool.js

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+import { createSuccessResult, createErrorResult } from '../index.js';
+import { RecommendationService } from '@magic-ingredients/tiny-brain-core';
+const RecommendationsArgsSchema = z.object({
+    operation: z.enum(['list', 'accept', 'dismiss', 'restore', 'graduated']),
+    items: z.array(z.string()).optional(),
+});
+export class RecommendationsTool {
+    static getToolDefinition() {
+        return {
+            name: 'recommendations',
+            description: `Manage skill, agent, and hook recommendations for your repository.
+
+Operations:
+  - list: Show pending recommendations grouped by type
+  - accept: Accept recommendations by name (installs them)
+  - dismiss: Dismiss recommendations by name
+  - restore: Restore previously dismissed recommendations
+  - graduated: Show all accepted/installed recommendations with provenance`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    operation: {
+                        type: 'string',
+                        enum: ['list', 'accept', 'dismiss', 'restore', 'graduated'],
+                        description: 'The recommendations operation to perform',
+                    },
+                    items: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Recommendation names (required for accept, dismiss, restore)',
+                    },
+                },
+                required: ['operation'],
+            },
+        };
+    }
+    static async execute(args, context) {
+        try {
+            const validatedArgs = RecommendationsArgsSchema.parse(args);
+            if (!context.repositoryRoot) {
+                return createErrorResult('Repository root is required for recommendations');
+            }
+            const service = new RecommendationService(context.repositoryRoot);
+            switch (validatedArgs.operation) {
+                case 'list':
+                    return await RecommendationsTool.handleList(service);
+                case 'accept':
+                    return await RecommendationsTool.handleAccept(validatedArgs, service);
+                case 'dismiss':
+                    return await RecommendationsTool.handleDismiss(validatedArgs, service);
+                case 'restore':
+                    return await RecommendationsTool.handleRestore(validatedArgs, service);
+                case 'graduated':
+                    return await RecommendationsTool.handleGraduated(service);
+                default:
+                    return createErrorResult(`Unknown operation: ${validatedArgs.operation}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return createErrorResult(`Invalid arguments: ${error.errors.map((e) => e.message).join(', ')}`);
+            }
+            return createErrorResult(error instanceof Error ? error.message : 'Unknown error occurred');
+        }
+    }
+    static async handleList(service) {
+        const pending = await service.getPendingRecommendations();
+        if (pending.length === 0) {
+            return createSuccessResult('No pending recommendations. Run `analyse` to fetch new recommendations.');
+        }
+        const grouped = {};
+        for (const rec of pending) {
+            const typeLabel = rec.type === 'skill' ? 'Skills' : rec.type === 'agent' ? 'Agents' : 'Hooks';
+            if (!grouped[typeLabel]) {
+                grouped[typeLabel] = [];
+            }
+            grouped[typeLabel].push(rec);
+        }
+        const lines = ['# Pending Recommendations', ''];
+        for (const [type, recs] of Object.entries(grouped)) {
+            lines.push(`## ${type}`, '');
+            for (const rec of recs) {
+                lines.push(`- **${rec.name}**: ${rec.description}`);
+                lines.push(`  _Reason: ${rec.reason}_`);
+            }
+            lines.push('');
+        }
+        lines.push('---', '', 'Use `accept` with item names to install recommendations.');
+        return createSuccessResult(lines.join('\n'));
+    }
+    static async handleAccept(args, service) {
+        if (!args.items || args.items.length === 0) {
+            return createErrorResult('`items` is required for accept operation');
+        }
+        const recsFile = await service.readRecommendations();
+        if (!recsFile) {
+            return createErrorResult('No recommendations file found. Run `analyse` first.');
+        }
+        const results = ['# Accept Results', ''];
+        for (const name of args.items) {
+            const match = recsFile.recommendations.find((r) => r.name.toLowerCase() === name.toLowerCase());
+            if (!match) {
+                results.push(`- **${name}**: Not found (unrecognized name)`);
+                continue;
+            }
+            try {
+                await service.acceptRecommendation(match);
+                results.push(`- **${match.name}**: Accepted`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : 'Unknown error';
+                results.push(`- **${match.name}**: Failed - ${msg}`);
+            }
+        }
+        return createSuccessResult(results.join('\n'));
+    }
+    static async handleDismiss(args, service) {
+        if (!args.items || args.items.length === 0) {
+            return createErrorResult('`items` is required for dismiss operation');
+        }
+        const recsFile = await service.readRecommendations();
+        if (!recsFile) {
+            return createErrorResult('No recommendations file found. Run `analyse` first.');
+        }
+        const results = ['# Dismiss Results', ''];
+        for (const name of args.items) {
+            const match = recsFile.recommendations.find((r) => r.name.toLowerCase() === name.toLowerCase());
+            if (!match) {
+                results.push(`- **${name}**: Not found (unrecognized name)`);
+                continue;
+            }
+            await service.dismissRecommendation(match.id);
+            results.push(`- **${match.name}**: Dismissed`);
+        }
+        return createSuccessResult(results.join('\n'));
+    }
+    static async handleRestore(args, service) {
+        if (!args.items || args.items.length === 0) {
+            return createErrorResult('`items` is required for restore operation');
+        }
+        const recsFile = await service.readRecommendations();
+        if (!recsFile) {
+            return createErrorResult('No recommendations file found. Run `analyse` first.');
+        }
+        const dismissed = await service.readDismissedRecommendations();
+        const dismissedIds = new Set(dismissed.map((d) => d.recommendationId));
+        const results = ['# Restore Results', ''];
+        for (const name of args.items) {
+            const match = recsFile.recommendations.find((r) => r.name.toLowerCase() === name.toLowerCase());
+            if (!match) {
+                results.push(`- **${name}**: Not found (unrecognized name)`);
+                continue;
+            }
+            if (!dismissedIds.has(match.id)) {
+                results.push(`- **${match.name}**: Not dismissed (nothing to restore)`);
+                continue;
+            }
+            await service.restoreRecommendation(match.id);
+            results.push(`- **${match.name}**: Restored`);
+        }
+        return createSuccessResult(results.join('\n'));
+    }
+    static async handleGraduated(service) {
+        const installed = await service.readInstalledRecommendations();
+        if (installed.length === 0) {
+            return createSuccessResult('No graduated recommendations yet. Use `accept` to install recommendations.');
+        }
+        const lines = ['# Graduated Recommendations', ''];
+        for (const item of installed) {
+            const { origin } = item;
+            lines.push(`- **${origin.recommendationName}** (${origin.type})`);
+            lines.push(`  Source: ${origin.source}`);
+            lines.push(`  Accepted: ${origin.acceptedAt}`);
+        }
+        return createSuccessResult(lines.join('\n'));
+    }
+}

package/dist/tools/tool-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../../src/tools/tool-registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,QAAQ,IAAI,OAAO,EAAE;IAuC5B;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;CAoB9D;AAGD,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,8BAAqC,CAAC;AAChF,eAAO,MAAM,eAAe,gBAAyD,CAAC"}
+{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../../src/tools/tool-registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgBH,OAAO,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,QAAQ,IAAI,OAAO,EAAE;IA0C5B;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;CAqB9D;AAGD,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,8BAAqC,CAAC;AAChF,eAAO,MAAM,eAAe,gBAAyD,CAAC"}

package/dist/tools/tool-registry.js

@@ -16,6 +16,7 @@ import { AnalyseTool } from './analyse.tool.js';
 import { QualityTool } from './quality/quality.tool.js';
 import { ConfigTool } from './config/config.tool.js';
 import { DashboardTool } from './dashboard/dashboard.tool.js';
+import { RecommendationsTool } from './recommendations/recommendations.tool.js';
 export class ToolRegistry {
     /**
      * Get all available tool definitions from all tools
@@ -39,6 +40,8 @@ export class ToolRegistry {
             ConfigTool.getToolDefinition(),
             // Dashboard tool - restart dashboard server (dev maintenance)
             DashboardTool.getToolDefinition(),
+            // Recommendations tool - browse, accept, dismiss recommendations
+            RecommendationsTool.getToolDefinition(),
             // Response tools (disabled for later release)
             // AnalyseRequestTool.getToolDefinition(),
             // ValidateResponseTool.getToolDefinition(),
@@ -67,6 +70,7 @@ export class ToolRegistry {
             quality: QualityTool,
             config: ConfigTool,
             dev_restart_dashboard: DashboardTool,
+            recommendations: RecommendationsTool,
         };
         return toolMap[name];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-ingredients/tiny-brain-local",
-  "version": "0.20.1",
+  "version": "0.21.1",
   "description": "MCP server for Tiny Brain AI assistant",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
     "dev": "tsx src/index.ts",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src",
+    "lint": "eslint --cache src",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "dxt:clean": "rm -rf dxt/node_modules dxt/package-lock.json dxt/dist dxt/server/index.js",
@@ -31,7 +31,7 @@
     "dxt:init": "cd dxt && dxt init"
   },
   "dependencies": {
-    "@magic-ingredients/tiny-brain-core": "^0.20.1",
+    "@magic-ingredients/tiny-brain-core": "^0.21.1",
     "@magic-ingredients/tiny-brain-dashboard": "file:../tiny-brain-dashboard",
     "@modelcontextprotocol/sdk": "^1.0.6",
     "chalk": "^5.3.0",
@@ -42,13 +42,7 @@
   },
   "devDependencies": {
     "@types/minimatch": "^5.1.2",
-    "@types/node": "^20.14.2",
-    "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^2.1.8",
-    "eslint": "^8.57.0",
-    "tsx": "^4.19.2",
-    "typescript": "^5.4.5",
-    "vitest": "^2.1.8"
+    "@types/semver": "^7.7.1"
   },
   "engines": {
     "node": ">=18.0.0"