monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/commands/index.js

@@ -16,37 +16,27 @@ import { swarmCommand } from './swarm.js';
 import { memoryCommand } from './memory.js';
 import { mcpCommand } from './mcp.js';
 import { hooksCommand } from './hooks.js';
-import { daemonCommand } from './daemon.js';
 import { doctorCommand } from './doctor.js';
 import { performanceCommand } from './performance.js';
 import { securityCommand } from './security.js';
-import { hiveMindCommand } from './hive-mind.js';
 import browseCommand from './browse.js';
 import { configCommand } from './config.js';
 import { completionsCommand } from './completions.js';
-import { workflowCommand } from './workflow.js';
 import { analyzeCommand } from './analyze.js';
 import { routeCommand } from './route.js';
 import { providersCommand } from './providers.js';
-import { claimsCommand } from './claims.js';
-import { issuesCommand } from './issues.js';
 import updateCommand from './update.js';
 import { guidanceCommand } from './guidance.js';
 import { cleanupCommand } from './cleanup.js';
 import { autopilotCommand } from './autopilot.js';
 import { monographCommand } from './monograph.js';
-import replayCommand from './replay.js';
-import storeCommand from './transfer-store.js';
 import tokensCommand from './tokens.js';
 import { platformsCommand } from './platforms.js';
 import { designCommand } from './design-detect.js';
-import { enrichCommand } from './enrich.js';
 import { searchUniversalCommand } from './search-universal.js';
-import { scanCommand } from './scan.js';
 import { reportCrashCommand } from './report-crash.js';
 import { crashReportingCommand } from './crash-reporting.js';
 import { docCommand } from './doc.js';
-import { neuralCommand } from './neural.js';
 // Populate command cache
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -58,37 +48,27 @@ loadedCommands.set('swarm', swarmCommand);
 loadedCommands.set('memory', memoryCommand);
 loadedCommands.set('mcp', mcpCommand);
 loadedCommands.set('hooks', hooksCommand);
-loadedCommands.set('daemon', daemonCommand);
 loadedCommands.set('doctor', doctorCommand);
 loadedCommands.set('performance', performanceCommand);
 loadedCommands.set('security', securityCommand);
-loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
 loadedCommands.set('cleanup', cleanupCommand);
 loadedCommands.set('autopilot', autopilotCommand);
 loadedCommands.set('monograph', monographCommand);
-loadedCommands.set('replay', replayCommand);
-loadedCommands.set('transfer-store', storeCommand);
 loadedCommands.set('tokens', tokensCommand);
 loadedCommands.set('platforms', platformsCommand);
 loadedCommands.set('browse', browseCommand);
 loadedCommands.set('config', configCommand);
 loadedCommands.set('completions', completionsCommand);
-loadedCommands.set('workflow', workflowCommand);
 loadedCommands.set('analyze', analyzeCommand);
 loadedCommands.set('route', routeCommand);
 loadedCommands.set('providers', providersCommand);
-loadedCommands.set('claims', claimsCommand);
-loadedCommands.set('issues', issuesCommand);
 loadedCommands.set('update', updateCommand);
 loadedCommands.set('design', designCommand);
-loadedCommands.set('enrich', enrichCommand);
 loadedCommands.set('search', searchUniversalCommand);
-loadedCommands.set('scan', scanCommand);
 loadedCommands.set('report-crash', reportCrashCommand);
 loadedCommands.set('crash-reporting', crashReportingCommand);
 loadedCommands.set('doc', docCommand);
-loadedCommands.set('neural', neuralCommand);
 // =============================================================================
 // Exports
 // =============================================================================
@@ -102,24 +82,19 @@ export { swarmCommand } from './swarm.js';
 export { memoryCommand } from './memory.js';
 export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
-export { daemonCommand } from './daemon.js';
 export { doctorCommand } from './doctor.js';
 export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
-export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { cleanupCommand } from './cleanup.js';
 export { autopilotCommand } from './autopilot.js';
 export { monographCommand } from './monograph.js';
 export { platformsCommand } from './platforms.js';
 export { designCommand } from './design-detect.js';
-export { enrichCommand } from './enrich.js';
 export { searchUniversalCommand } from './search-universal.js';
-export { scanCommand } from './scan.js';
 export { reportCrashCommand } from './report-crash.js';
 export { crashReportingCommand } from './crash-reporting.js';
 export { docCommand } from './doc.js';
-export { neuralCommand } from './neural.js';
 /**
  * All registered commands
  */
@@ -134,37 +109,27 @@ export const commands = [
     memoryCommand,
     mcpCommand,
     hooksCommand,
-    daemonCommand,
     doctorCommand,
     performanceCommand,
     securityCommand,
-    hiveMindCommand,
     guidanceCommand,
     cleanupCommand,
     autopilotCommand,
     monographCommand,
     platformsCommand,
     designCommand,
-    enrichCommand,
     searchUniversalCommand,
-    scanCommand,
     docCommand,
     crashReportingCommand,
     browseCommand,
     configCommand,
     completionsCommand,
-    workflowCommand,
     analyzeCommand,
     routeCommand,
     providersCommand,
-    claimsCommand,
-    issuesCommand,
     updateCommand,
-    replayCommand,
-    storeCommand,
     tokensCommand,
     reportCrashCommand,
-    neuralCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -186,34 +151,24 @@ export const commandsByCategory = {
     advanced: [
         securityCommand,
         performanceCommand,
-        hiveMindCommand,
         guidanceCommand,
         autopilotCommand,
-        neuralCommand,
     ],
     utility: [
         configCommand,
         doctorCommand,
-        daemonCommand,
         completionsCommand,
-        workflowCommand,
     ],
     analysis: [
         analyzeCommand,
         routeCommand,
         monographCommand,
-        replayCommand,
         tokensCommand,
-        enrichCommand,
         searchUniversalCommand,
-        scanCommand,
     ],
     management: [
         providersCommand,
-        claimsCommand,
-        issuesCommand,
         updateCommand,
-        storeCommand,
         cleanupCommand,
         platformsCommand,
         browseCommand,

package/packages/@monomind/cli/dist/src/commands/init-wizard.js

@@ -59,7 +59,7 @@ export const wizardCommand = {
                     const skillSets = await multiSelect({
                         message: 'Select skill sets:',
                         options: [
-                            { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC skills', selected: true },
+                            { value: 'core', label: 'Core', hint: 'Swarm, memory skills', selected: true },
                             { value: 'memory', label: 'Memory (LanceDB)', hint: 'Vector database skills', selected: true },
                             { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
                         ],

package/packages/@monomind/cli/dist/src/commands/init.js

@@ -167,11 +167,10 @@ const initAction = async (ctx) => {
         }
         const noStartAll = ctx.flags['no-start-all'] || ctx.flags.noStartAll;
         const startAll = noStartAll ? false : (ctx.flags['start-all'] ?? ctx.flags.startAll ?? true);
-        const startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
-        if (startDaemon || startAll) {
+        if (startAll) {
             output.writeln();
             output.printInfo('Starting services...');
-            const { execSync, spawn: spawnChild } = await import('child_process');
+            const { execSync } = await import('child_process');
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing memory database...'));
@@ -186,17 +185,6 @@ const initAction = async (ctx) => {
                     output.writeln(output.dim('  Memory database already exists'));
                 }
             }
-            if (startDaemon) {
-                try {
-                    output.writeln(output.dim('  Starting daemon...'));
-                    const daemonProc = spawnChild(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'daemon', 'start'], { stdio: 'ignore', detached: true, cwd: ctx.cwd });
-                    daemonProc.unref();
-                    output.writeln(output.success('  ✓ Daemon started'));
-                }
-                catch {
-                    output.writeln(output.warning('  Daemon may already be running'));
-                }
-            }
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing swarm...'));
@@ -240,10 +228,9 @@ const initAction = async (ctx) => {
                 output.writeln(output.warning('  Embedding initialization skipped (run manually)'));
             }
         }
-        if (!startDaemon && !startAll) {
+        if (!startAll) {
             output.writeln(output.bold('Next steps:'));
             output.printList([
-                `Run ${output.highlight('monomind daemon start')} to start background workers`,
                 `Run ${output.highlight('monomind memory init')} to initialize memory database`,
                 `Run ${output.highlight('monomind swarm init')} to initialize a swarm`,
                 `Services auto-start by default; use ${output.highlight('--no-start-all')} to skip`,
@@ -318,16 +305,10 @@ export const initCommand = {
         },
         {
             name: 'start-all',
-            description: 'Auto-start daemon, memory, and swarm after init (default: true)',
+            description: 'Auto-start memory and swarm after init (default: true)',
             type: 'boolean',
             default: true,
         },
-        {
-            name: 'start-daemon',
-            description: 'Auto-start daemon after init',
-            type: 'boolean',
-            default: false,
-        },
         {
             name: 'no-watch',
             description: 'Skip starting the monograph knowledge graph watcher after init',
@@ -351,7 +332,6 @@ export const initCommand = {
     examples: [
         { command: 'monomind init', description: 'Initialize with default configuration' },
         { command: 'monomind init --no-start-all', description: 'Initialize without auto-starting services' },
-        { command: 'monomind init --start-daemon', description: 'Initialize and start daemon only' },
         { command: 'monomind init --minimal', description: 'Initialize with minimal configuration' },
         { command: 'monomind init --full', description: 'Initialize with all components' },
         { command: 'monomind init --force', description: 'Reinitialize and overwrite existing config' },

package/packages/@monomind/cli/dist/src/commands/neural-core.js

@@ -11,8 +11,8 @@ export const statusCommand = {
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
     ],
     examples: [
-        { command: 'monomind neural status', description: 'Show pattern-learning status' },
-        { command: 'monomind neural status -v', description: 'Show detailed metrics' },
+        { command: 'monomind hooks intelligence status', description: 'Show pattern-learning status' },
+        { command: 'monomind hooks intelligence status -v', description: 'Show detailed metrics' },
     ],
     action: async (ctx) => {
         const verbose = ctx.flags.verbose === true;
@@ -104,8 +104,8 @@ export const patternsCommand = {
         { name: 'limit', short: 'l', type: 'number', description: 'Max patterns to return', default: '10' },
     ],
     examples: [
-        { command: 'monomind neural patterns --action list', description: 'List all patterns' },
-        { command: 'monomind neural patterns -a analyze -q "error handling"', description: 'Analyze patterns' },
+        { command: 'monomind hooks intelligence patterns --action list', description: 'List all patterns' },
+        { command: 'monomind hooks intelligence patterns -a analyze -q "error handling"', description: 'Analyze patterns' },
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
@@ -123,7 +123,7 @@ export const patternsCommand = {
                 const allPatterns = await getAllPatterns();
                 const patterns = query ? await findSimilarPatterns(query, { k: limit }) : allPatterns.slice(0, limit);
                 if (patterns.length === 0) {
-                    output.writeln(output.dim('No patterns found. Train some patterns first with: neural train'));
+                    output.writeln(output.dim('No patterns found. Train some patterns first with: hooks intelligence train'));
                     output.writeln();
                     output.printBox([
                         `Total Patterns: ${stats.patternsLearned}`,
@@ -184,7 +184,7 @@ export const patternsCommand = {
         }
         catch {
             output.writeln(output.dim('Intelligence system not initialized.'));
-            output.writeln(output.dim('Run: monomind neural train --pattern-type general'));
+            output.writeln(output.dim('Run: monomind hooks intelligence train --pattern-type general'));
             return { success: false };
         }
     },
@@ -198,8 +198,8 @@ export const trainCommand = {
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show each ingested pattern' },
     ],
     examples: [
-        { command: 'monomind neural train', description: 'Ingest outcomes and edits into pattern store' },
-        { command: 'monomind neural train -t security -v', description: 'Ingest with type label, verbose' },
+        { command: 'monomind hooks intelligence train', description: 'Ingest outcomes and edits into pattern store' },
+        { command: 'monomind hooks intelligence train -t security -v', description: 'Ingest with type label, verbose' },
     ],
     action: async (ctx) => {
         const patternType = ctx.flags['pattern-type'] || 'general';
@@ -337,8 +337,8 @@ export const predictCommand = {
         { name: 'format', short: 'f', type: 'string', description: 'Output format: json, table', default: 'table' },
     ],
     examples: [
-        { command: 'monomind neural predict -i "implement authentication"', description: 'Predict routing for task' },
-        { command: 'monomind neural predict -i "fix bug in login" -k 3', description: 'Get top 3 predictions' },
+        { command: 'monomind hooks intelligence predict -i "implement authentication"', description: 'Predict routing for task' },
+        { command: 'monomind hooks intelligence predict -i "fix bug in login" -k 3', description: 'Get top 3 predictions' },
     ],
     action: async (ctx) => {
         const inputText = ctx.flags.input;
@@ -362,7 +362,7 @@ export const predictCommand = {
             spinner.succeed(`Prediction complete (search: ${searchTime.toFixed(1)}ms)`);
             output.writeln();
             if (matches.length === 0) {
-                output.writeln(output.warning('No similar patterns found. Try training first: monomind neural train'));
+                output.writeln(output.warning('No similar patterns found. Try training first: monomind hooks intelligence train'));
                 return { success: true, data: { matches: [] } };
             }
             if (format === 'json') {

package/packages/@monomind/cli/dist/src/commands/neural-optimize.js

@@ -11,8 +11,8 @@ export const optimizeCommand = {
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
     ],
     examples: [
-        { command: 'monomind neural optimize --method quantize', description: 'Quantize patterns to Int8' },
-        { command: 'monomind neural optimize --method analyze -v', description: 'Analyze memory usage' },
+        { command: 'monomind hooks intelligence optimize --method quantize', description: 'Quantize patterns to Int8' },
+        { command: 'monomind hooks intelligence optimize --method analyze -v', description: 'Analyze memory usage' },
     ],
     action: async (ctx) => {
         const method = ctx.flags.method || 'quantize';
@@ -54,9 +54,8 @@ export const optimizeCommand = {
                     return { ...p, embedding: int8Embedding, _quantized: true, _scale: scale };
                 });
                 const patternFile = path.join(patternDir, 'patterns.json');
-                const tmpFile = `${patternFile}.${process.pid}.tmp`;
-                fs.writeFileSync(tmpFile, JSON.stringify(quantizedPatterns, null, 2), 'utf-8');
-                fs.renameSync(tmpFile, patternFile);
+                const { writeJsonFileAtomic } = await import('../utils/json-file.js');
+                writeJsonFileAtomic(patternFile, quantizedPatterns);
                 spinner.succeed(`Quantized ${quantized} patterns`);
                 output.writeln();
                 output.printTable({
@@ -148,8 +147,8 @@ export const exportCommand = {
         { name: 'name', short: 'n', type: 'string', description: 'Custom name for exported model' },
     ],
     examples: [
-        { command: 'monomind neural export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
-        { command: 'monomind neural export -m code-review -o ./export.json', description: 'Export to file' },
+        { command: 'monomind hooks intelligence export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
+        { command: 'monomind hooks intelligence export -m code-review -o ./export.json', description: 'Export to file' },
     ],
     action: async (ctx) => {
         const modelId = ctx.flags.model || 'all';
@@ -267,9 +266,8 @@ export const exportCommand = {
                     spinner.fail(`--output path escapes project directory: ${outputFile}`);
                     return { success: false, exitCode: 1 };
                 }
-                const tmpOutput = outputFile + '.tmp';
-                fs.writeFileSync(tmpOutput, JSON.stringify(exportPackage, null, 2));
-                fs.renameSync(tmpOutput, outputFile);
+                const { writeJsonFileAtomic } = await import('../utils/json-file.js');
+                writeJsonFileAtomic(resolvedOut, exportPackage);
                 spinner.succeed(`Exported to: ${outputFile}`);
             }
             if (pinToIpfs) {
@@ -314,7 +312,7 @@ export const exportCommand = {
                 });
                 output.writeln();
                 output.writeln(output.success('Share this CID for others to import your trained patterns'));
-                output.writeln(output.dim(`Import command: monomind neural import --cid ${result.IpfsHash}`));
+                output.writeln(output.dim(`Import command: monomind hooks intelligence import --cid ${result.IpfsHash}`));
             }
             if (!outputFile && !pinToIpfs) {
                 spinner.succeed('Export prepared');

package/packages/@monomind/cli/dist/src/commands/neural-registry.js

@@ -12,9 +12,9 @@ export const listCommand = {
         { name: 'cid', type: 'string', description: 'Custom registry CID (default: official registry)' },
     ],
     examples: [
-        { command: 'monomind neural list', description: 'List all available models' },
-        { command: 'monomind neural list --category security', description: 'List only security models' },
-        { command: 'monomind neural list -f json', description: 'Output as JSON' },
+        { command: 'monomind hooks intelligence list', description: 'List all available models' },
+        { command: 'monomind hooks intelligence list --category security', description: 'List only security models' },
+        { command: 'monomind hooks intelligence list -f json', description: 'Output as JSON' },
     ],
     action: async (ctx) => {
         const category = ctx.flags.category;
@@ -96,12 +96,12 @@ export const listCommand = {
                 output.writeln(output.dim('Registry CID: ' + registryCid));
                 output.writeln();
                 output.writeln(output.bold('Import Commands:'));
-                output.writeln(output.dim('  All models:      ') + `monomind neural import --cid ${registryCid}`);
+                output.writeln(output.dim('  All models:      ') + `monomind hooks intelligence import --cid ${registryCid}`);
                 if (category) {
-                    output.writeln(output.dim(`  ${category} only: `) + `monomind neural import --cid ${registryCid} --category ${category}`);
+                    output.writeln(output.dim(`  ${category} only: `) + `monomind hooks intelligence import --cid ${registryCid} --category ${category}`);
                 }
                 else {
-                    output.writeln(output.dim('  By category:     ') + `monomind neural import --cid ${registryCid} --category <category>`);
+                    output.writeln(output.dim('  By category:     ') + `monomind hooks intelligence import --cid ${registryCid} --category <category>`);
                 }
             }
             return { success: true };
@@ -124,9 +124,9 @@ export const importCommand = {
         { name: 'category', type: 'string', description: 'Only import patterns from specific category' },
     ],
     examples: [
-        { command: 'monomind neural import --cid QmXxx...', description: 'Import from IPFS' },
-        { command: 'monomind neural import -f ./patterns.json --verify', description: 'Import from file' },
-        { command: 'monomind neural import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
+        { command: 'monomind hooks intelligence import --cid QmXxx...', description: 'Import from IPFS' },
+        { command: 'monomind hooks intelligence import -f ./patterns.json --verify', description: 'Import from file' },
+        { command: 'monomind hooks intelligence import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
     ],
     action: async (ctx) => {
         const cid = ctx.flags.cid;
@@ -278,7 +278,7 @@ export const importCommand = {
             });
             output.writeln();
             output.writeln(output.success('Patterns imported and ready to use'));
-            output.writeln(output.dim('Run "monomind neural patterns --action list" to see imported patterns'));
+            output.writeln(output.dim('Run "monomind hooks intelligence patterns --action list" to see imported patterns'));
             return { success: true };
         }
         catch (error) {

package/packages/@monomind/cli/dist/src/commands/providers.js

@@ -234,13 +234,100 @@ const testCommand = {
         }
     },
 };
+// List subcommand
+const listCommand = {
+    name: 'list',
+    description: 'List configured providers',
+    options: [
+        { name: 'json', short: 'j', type: 'boolean', description: 'Output as JSON' },
+    ],
+    examples: [
+        { command: 'monomind providers list', description: 'List all configured providers' },
+    ],
+    action: async (ctx) => {
+        try {
+            const cwd = process.cwd();
+            const config = configManager.getConfig(cwd);
+            const agents = (config.agents ?? {});
+            const providers = (agents.providers ?? []);
+            if (ctx.flags.json) {
+                const redacted = providers.map((p) => ({
+                    ...p,
+                    apiKey: p.apiKey ? '***configured***' : undefined,
+                }));
+                output.printJson(redacted);
+                return { success: true, data: redacted };
+            }
+            output.writeln();
+            output.writeln(output.bold('Configured Providers'));
+            output.writeln(output.dim('─'.repeat(40)));
+            if (providers.length === 0) {
+                output.writeln(output.dim('  No providers configured. Use "providers configure -p <name>" to add one.'));
+            }
+            else {
+                for (const p of providers) {
+                    const name = String(p.name ?? 'unknown');
+                    const hasKey = p.apiKey ? 'key set' : 'no key';
+                    const model = p.model ? `, model: ${p.model}` : '';
+                    output.writeln(`  ${output.highlight(name)} — ${hasKey}${model}`);
+                }
+            }
+            output.writeln();
+            return { success: true, data: providers };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.printError(`Failed to list providers: ${msg}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+// Remove subcommand
+const removeCommand = {
+    name: 'remove',
+    description: 'Remove a configured provider',
+    options: [
+        { name: 'provider', short: 'p', type: 'string', description: 'Provider name', required: true },
+    ],
+    examples: [
+        { command: 'monomind providers remove -p openai', description: 'Remove OpenAI provider config' },
+    ],
+    action: async (ctx) => {
+        try {
+            const provider = (ctx.flags.provider || (ctx.args && ctx.args[0]) || '').slice(0, 64);
+            if (!provider) {
+                output.printError('Provider name is required. Use -p <name> or pass as first argument.');
+                return { success: false, exitCode: 1 };
+            }
+            const cwd = process.cwd();
+            const config = configManager.getConfig(cwd);
+            const agents = (config.agents ?? {});
+            const providers = (agents.providers ?? []);
+            const filtered = providers.filter((p) => !(typeof p.name === 'string' && p.name.toLowerCase() === provider.toLowerCase()));
+            if (filtered.length === providers.length) {
+                output.printWarning(`Provider "${provider}" was not configured.`);
+                return { success: true };
+            }
+            configManager.set(cwd, 'agents.providers', filtered);
+            output.writeln(output.success(`Provider "${provider}" removed.`));
+            return { success: true };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.printError(`Failed to remove provider: ${msg}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
 // Main providers command
 export const providersCommand = {
     name: 'providers',
     description: 'Manage AI providers, models, and configurations',
-    subcommands: [configureCommand, testCommand],
+    subcommands: [listCommand, configureCommand, removeCommand, testCommand],
     examples: [
+        { command: 'monomind providers list', description: 'List configured providers' },
         { command: 'monomind providers configure -p openai -k sk-...', description: 'Configure OpenAI' },
+        { command: 'monomind providers remove -p openai', description: 'Remove OpenAI config' },
         { command: 'monomind providers test --all', description: 'Test all providers' },
     ],
     action: async () => {
@@ -250,7 +337,9 @@ export const providersCommand = {
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
+            'list      - List configured providers',
             'configure - Configure provider settings and API keys',
+            'remove    - Remove a configured provider',
             'test      - Test provider connectivity',
         ]);
         output.writeln();

package/packages/@monomind/cli/dist/src/commands/search-universal.d.ts

@@ -5,9 +5,15 @@
  * renders merged, score-ranked results grouped by content type.
  */
 import type { Command } from '../types.js';
-import type { SearchResult, CapabilityName } from '../capabilities/types.js';
+import type { SearchResult, CapabilityName, DirectoryScan } from '../capabilities/types.js';
 export declare function groupByType(results: SearchResult[]): Partial<Record<CapabilityName, SearchResult[]>>;
 export declare function formatSearchResults(results: SearchResult[]): string;
+/**
+ * Scan the working directory for content-type capabilities and persist an
+ * updated fingerprint to .monomind/. Shared by `search scan` and the
+ * auto-rescan path in `search` (formerly the standalone `scan` command).
+ */
+export declare function runCapabilityScan(cwd: string): Promise<DirectoryScan>;
 export declare const searchUniversalCommand: Command;
 export default searchUniversalCommand;
 //# sourceMappingURL=search-universal.d.ts.map

package/packages/@monomind/cli/dist/src/commands/search-universal.js

@@ -1,5 +1,5 @@
 import { CapabilityManager } from '../capabilities/manager.js';
-import { loadFingerprint, listFiles } from '../capabilities/scanner.js';
+import { loadFingerprint, listFiles, scanDirectory, saveFingerprint } from '../capabilities/scanner.js';
 import { codeCapability } from '../capabilities/cap-code.js';
 import { documentsCapability } from '../capabilities/cap-documents.js';
 import { mediaCapability } from '../capabilities/cap-media.js';
@@ -47,23 +47,77 @@ export function formatSearchResults(results) {
     }
     return lines.join('\n');
 }
+/** Fingerprints older than this are considered stale and trigger a rescan. */
+const FINGERPRINT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Scan the working directory for content-type capabilities and persist an
+ * updated fingerprint to .monomind/. Shared by `search scan` and the
+ * auto-rescan path in `search` (formerly the standalone `scan` command).
+ */
+export async function runCapabilityScan(cwd) {
+    const scan = await scanDirectory(cwd);
+    const monomindDir = path.join(cwd, '.monomind');
+    await saveFingerprint(scan, monomindDir);
+    return scan;
+}
+function isFingerprintStale(scannedAt) {
+    const ts = new Date(scannedAt).getTime();
+    return isNaN(ts) || Date.now() - ts > FINGERPRINT_MAX_AGE_MS;
+}
+const scanSubcommand = {
+    name: 'scan',
+    description: 'Scan directory and update capability fingerprint',
+    action: async (ctx) => {
+        try {
+            const scan = await runCapabilityScan(ctx.cwd);
+            console.log(`\nScanned ${scan.totalFiles} files in ${scan.root}`);
+            console.log(`Git: ${scan.git ? 'yes' : 'no'}`);
+            console.log(`\nCapabilities detected:`);
+            for (const [name, score] of Object.entries(scan.capabilities)) {
+                if (score.confidence > 0.1) {
+                    console.log(`  ✓ ${name} (${(score.confidence * 100).toFixed(0)}% confidence, ${score.files} files)`);
+                }
+            }
+            const inactive = Object.entries(scan.capabilities).filter(([, s]) => s.confidence <= 0.1);
+            if (inactive.length > 0) {
+                console.log(`\nNot detected: ${inactive.map(([n]) => n).join(', ')}`);
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, message: error instanceof Error ? error.message : String(error) };
+        }
+    },
+};
 export const searchUniversalCommand = {
     name: 'search',
     description: 'Search across all content types',
+    subcommands: [scanSubcommand],
     options: [
         { name: 'limit', description: 'Max results', type: 'number' },
         { name: 'type', description: 'Filter by type (documents, media, data, code)', type: 'string' },
     ],
+    examples: [
+        { command: 'monomind search "auth middleware"', description: 'Search all content types' },
+        { command: 'monomind search scan', description: 'Rescan directory and update capability fingerprint' },
+    ],
     action: async (ctx) => {
         const query = ctx.args.join(' ');
         if (!query) {
             return { success: false, message: 'Usage: monomind search <query>' };
         }
         const monomindDir = path.join(ctx.cwd, '.monomind');
-        const fingerprint = await loadFingerprint(monomindDir);
-        if (!fingerprint) {
-            console.log('No directory scan found. Run `monomind init` or `monomind scan` first.');
-            return { success: true };
+        let fingerprint = await loadFingerprint(monomindDir);
+        // Auto-scan when the fingerprint is missing or stale instead of bailing out
+        if (!fingerprint || isFingerprintStale(fingerprint.scannedAt)) {
+            console.log(fingerprint ? 'Capability fingerprint is stale — rescanning...' : 'No directory scan found — scanning...');
+            try {
+                const scan = await runCapabilityScan(ctx.cwd);
+                fingerprint = { version: 1, ...scan };
+            }
+            catch (err) {
+                return { success: false, message: `Scan failed: ${err instanceof Error ? err.message : String(err)}` };
+            }
         }
         const mgr = new CapabilityManager();
         mgr.register(codeCapability);