maestro-flow 0.5.35 → 0.5.37

package/dist/src/commands/search.js

@@ -1,19 +1,33 @@
 /**
- * Search Command — Unified knowledge search across specs, knowhow, issues, and more.
+ * Search Command — Unified knowledge search across wiki + code.
  *
- * Uses WikiIndexer BM25F search with deduplication and type filtering.
- * Optional --code flag adds CodeGraph AST results in a separate section.
+ * Default: mixed results (wiki + code interleaved by normalized score).
+ * --code: code graph results only (no wiki).
+ * --wiki-only: wiki results only (no code search).
+ *
+ * Scoring: multi-signal normalization inspired by codebase-memory-mcp.
+ *   Wiki:  BM25F score + type boost (spec > knowhow > note)
+ *   Code:  BM25 score + kind boost + name-match bonus
+ *   Merge: percentile-aware normalization + source weight
+ *
+ * Per-source caps: session ≤3, scratch ≤3 to prevent low-value source spam.
  */
 import { resolve } from 'node:path';
 import { truncate, extractSnippet, highlightTerms } from '../utils/cli-format.js';
-import { WikiIndexer } from '#maestro-dashboard/wiki/wiki-indexer.js';
 import { loadWorkspaceConfig, resolveWorkspaceLinks } from '../config/index.js';
-// Valid type filter values — matches WikiNodeType.
-const VALID_TYPES = ['project', 'roadmap', 'spec', 'issue', 'knowhow', 'note', 'domain'];
+import { tryDaemonSearch, stopDaemon, spawnDaemon, readDaemonInfo, isDaemonAlive, getDaemonPath } from '../search/daemon-client.js';
+// Valid type filter values — matches WikiNodeType + virtual aliases.
+const VALID_TYPES = ['project', 'roadmap', 'spec', 'issue', 'knowhow', 'note', 'domain', 'session', 'scratch'];
+// Per-category result caps — prevents low-value sources from dominating.
+const CATEGORY_CAPS = {
+    session: 3,
+    scratch: 3,
+};
 // ── Lazy offline client ────────────────────────────────────────────────
 let _indexer = null;
-function getIndexer() {
+async function getIndexer() {
     if (!_indexer) {
+        const { WikiIndexer: Cls } = await import('#maestro-dashboard/wiki/wiki-indexer.js');
         const workflowRoot = resolve('.workflow');
         const projectPath = process.cwd();
         const wsConfig = loadWorkspaceConfig(projectPath);
@@ -21,7 +35,7 @@ function getIndexer() {
         const linkedWorkspaces = resolved
             .filter(lw => lw.valid)
             .map(lw => ({ name: lw.name, workflowRoot: lw.workflowRoot, shareTypes: lw.share }));
-        _indexer = new WikiIndexer({ workflowRoot, linkedWorkspaces });
+        _indexer = new Cls({ workflowRoot, linkedWorkspaces });
     }
     return _indexer;
 }
@@ -29,13 +43,41 @@ let _lastSearchMeta = { embeddingUsed: false, embeddingDocs: 0 };
 export function getLastSearchMeta() { return _lastSearchMeta; }
 export async function runUnifiedSearch(q, opts) {
     const limit = opts.limit > 0 ? opts.limit : 20;
-    const indexer = getIndexer();
     const candidateLimit = Math.max(limit * 3, 60);
-    const { results: scored, embeddingUsed, embeddingDocs } = await indexer.searchWithMeta(q, candidateLimit);
+    // Try daemon first (warm ONNX model, no cold-start penalty)
+    const workflowRoot = resolve('.workflow');
+    const daemonResult = await tryDaemonSearch(workflowRoot, q, candidateLimit, opts.skipEmbedding);
+    let scored;
+    let embeddingUsed;
+    let embeddingDocs;
+    if (daemonResult?.ok && daemonResult.results) {
+        scored = daemonResult.results;
+        embeddingUsed = daemonResult.embeddingUsed ?? false;
+        embeddingDocs = daemonResult.embeddingDocs ?? 0;
+    }
+    else {
+        // Daemon unavailable — use BM25-only to avoid ONNX cold-start (~1800ms).
+        // Spawn daemon in background so future searches get embedding.
+        const indexer = await getIndexer();
+        const result = await indexer.searchWithMeta(q, candidateLimit, { skipEmbedding: true });
+        scored = result.results;
+        embeddingUsed = result.embeddingUsed;
+        embeddingDocs = result.embeddingDocs;
+        spawnDaemon(workflowRoot).catch(() => { });
+    }
     _lastSearchMeta = { embeddingUsed, embeddingDocs };
     let filtered = scored;
     if (opts.type) {
-        filtered = filtered.filter(r => r.entry.type === opts.type);
+        // Virtual type aliases: session/scratch map to category filter
+        if (opts.type === 'session') {
+            filtered = filtered.filter(r => r.entry.category === 'session');
+        }
+        else if (opts.type === 'scratch') {
+            filtered = filtered.filter(r => r.entry.category === 'scratch');
+        }
+        else {
+            filtered = filtered.filter(r => r.entry.type === opts.type);
+        }
     }
     if (opts.category) {
         filtered = filtered.filter(r => r.entry.category === opts.category);
@@ -43,11 +85,24 @@ export async function runUnifiedSearch(q, opts) {
     if (opts.workspace) {
         filtered = filtered.filter(r => r.entry.source.workspace === opts.workspace);
     }
+    // CATEGORY_CAPS only when user didn't explicitly filter by type/category
+    const applyCaps = !opts.type && !opts.category;
     const seen = new Set();
     const deduped = [];
+    const catCounts = new Map();
     for (const r of filtered) {
         if (seen.has(r.entry.id))
             continue;
+        if (applyCaps) {
+            const cat = r.entry.category ?? '';
+            const cap = CATEGORY_CAPS[cat];
+            if (cap !== undefined) {
+                const count = catCounts.get(cat) ?? 0;
+                if (count >= cap)
+                    continue;
+                catCounts.set(cat, count + 1);
+            }
+        }
         seen.add(r.entry.id);
         deduped.push(r);
         if (deduped.length >= limit)
@@ -92,6 +147,33 @@ function incrementSearchHitsAsync(entryIds) {
         }
     }).catch(() => { });
 }
+async function runKgSearch(q, limit) {
+    try {
+        const { MaestroGraph } = await import('../graph/kg/engine.js');
+        if (!MaestroGraph.isInitialized(resolve('.')))
+            return { results: [], summary: {} };
+        const mg = await MaestroGraph.open(resolve('.'));
+        try {
+            const output = mg.searchUnified(q, { limit });
+            const results = output.directMatches.map(r => ({
+                id: r.node.id,
+                sourceType: r.node.sourceType,
+                kind: r.node.kind,
+                name: r.node.name,
+                definition: r.node.definition?.substring(0, 120) || '',
+                filePath: r.node.filePath,
+                score: r.score,
+            }));
+            return { results, summary: output.summary };
+        }
+        finally {
+            mg.close();
+        }
+    }
+    catch {
+        return { results: [], summary: {} };
+    }
+}
 /**
  * Search MaestroGraph for code nodes matching the query. Gracefully returns
  * empty when MaestroGraph is not initialized.
@@ -124,105 +206,224 @@ async function runCodeSearch(q, limit) {
 export function registerSearchCommand(program) {
     program
         .command('search <query...>')
-        .description('Unified knowledge search across specs, knowhow, issues, and more')
+        .description('Unified knowledge search across wiki + code (mixed by default)')
         .option('--type <type>', `Filter by type: ${VALID_TYPES.join(', ')}`)
         .option('--category <cat>', 'Filter by category (e.g. coding, arch, debug, test, review, learning)')
-        .option('--code', 'Include CodeGraph code results')
-        .option('--all', 'Search all sources (wiki + code) with normalized ranking')
+        .option('--code', 'Code graph results only (no wiki)')
+        .option('--kg', 'KG unified search (MaestroGraph full-source)')
+        .option('--all', 'Alias for default mixed mode (backward compat)')
+        .option('--wiki-only', 'Search wiki only, skip code results')
         .option('--workspace <name>', 'Filter results to a specific linked workspace')
+        .option('--no-emb', 'Skip embedding, use BM25 only')
         .option('--limit <n>', 'Max results', '20')
         .option('--json', 'Output as JSON')
         .action(async (queryParts, opts) => {
         const q = queryParts.join(' ');
         const limit = parseInt(opts.limit, 10) || 20;
-        const includeCode = opts.code || opts.all;
+        const wikiOnly = opts.wikiOnly === true;
+        const codeOnly = opts.code === true && !opts.all;
+        const kgMode = opts.kg === true;
         if (opts.type && !VALID_TYPES.includes(opts.type)) {
             console.error(`Error: --type must be one of ${VALID_TYPES.join(', ')} (got "${opts.type}")`);
             process.exit(1);
         }
-        let wikiResults = await runUnifiedSearch(q, { type: opts.type, category: opts.category, workspace: opts.workspace, limit });
-        const codeResults = includeCode ? await runCodeSearch(q, limit) : [];
-        // --all: normalize and merge scores for unified ranking
-        if (opts.all) {
-            const merged = mergeAndNormalize(wikiResults, codeResults, limit);
+        const skipEmbedding = opts.emb === false;
+        const isTTY = process.stdout.isTTY === true;
+        const qTerms = q.toLowerCase().split(/\s+/).filter(Boolean);
+        // --kg: MaestroGraph unified search
+        if (kgMode) {
+            const { results: kgResults, summary } = await runKgSearch(q, limit);
             if (opts.json) {
-                console.log(JSON.stringify({ query: q, count: merged.length, results: merged }, null, 2));
+                console.log(JSON.stringify({ query: q, engine: 'maestrograph', count: kgResults.length, summary, results: kgResults }, null, 2));
                 return;
             }
-            console.log(`Search: "${q}" (${merged.length} results, all sources)`);
-            if (merged.length === 0) {
+            const parts = [];
+            if (summary.codeSymbols)
+                parts.push(`codegraph ${summary.codeSymbols}`);
+            if (summary.domainTerms)
+                parts.push(`domain ${summary.domainTerms}`);
+            if (summary.specRules)
+                parts.push(`spec ${summary.specRules}`);
+            if (summary.knowhowDocs)
+                parts.push(`knowhow ${summary.knowhowDocs}`);
+            const headerSummary = parts.length > 0 ? `${parts.join(' + ')} = ${kgResults.length}` : `${kgResults.length}`;
+            console.log(`Search: "${q}" (${headerSummary}, KG)`);
+            if (kgResults.length === 0) {
                 console.log('  No matches found.');
                 return;
             }
-            const isTTY = process.stdout.isTTY === true;
-            const qTerms = q.toLowerCase().split(/\s+/).filter(Boolean);
-            for (const r of merged) {
+            for (const r of kgResults) {
                 const name = isTTY ? highlightTerms(r.name, qTerms) : r.name;
-                const scoreTag = `  (${r.normalizedScore.toFixed(4)})`;
-                console.log(`  [${r.source}] [${r.kind}]  ${name}  ${r.detail}${scoreTag}`);
+                const def = r.definition ? `  ${truncate(r.definition, 70)}` : '';
+                const scoreTag = `  (${r.score.toFixed(1)})`;
+                console.log(`  [${r.sourceType}:${r.kind}]  ${name}${def}${scoreTag}`);
             }
             return;
         }
-        if (opts.json) {
-            const output = { query: q };
-            if (includeCode) {
-                output.wikiResults = wikiResults;
-                output.codeResults = codeResults;
-                output.wikiCount = wikiResults.length;
-                output.codeCount = codeResults.length;
+        // Parallel: wiki + code search (skip irrelevant source based on flags)
+        const [wikiResults, codeResults] = await Promise.all([
+            codeOnly ? [] : runUnifiedSearch(q, { type: opts.type, category: opts.category, workspace: opts.workspace, limit, skipEmbedding }),
+            wikiOnly ? [] : runCodeSearch(q, limit),
+        ]);
+        const meta = getLastSearchMeta();
+        const embTag = meta.embeddingUsed ? `+emb(${meta.embeddingDocs})` : 'bm25';
+        // --code: code graph results only
+        if (codeOnly) {
+            if (opts.json) {
+                console.log(JSON.stringify({ query: q, count: codeResults.length, results: codeResults }, null, 2));
+                return;
             }
-            else {
-                output.count = wikiResults.length;
-                output.results = wikiResults;
+            console.log(`Search: "${q}" (code ${codeResults.length}, ${embTag})`);
+            if (codeResults.length === 0) {
+                console.log('  No matches found.');
+                return;
+            }
+            for (const r of codeResults) {
+                printCodeResult(r, '  ', isTTY, qTerms);
             }
-            console.log(JSON.stringify(output, null, 2));
             return;
         }
-        const isTTY = process.stdout.isTTY === true;
-        const qTerms = q.toLowerCase().split(/\s+/).filter(Boolean);
-        const meta = getLastSearchMeta();
-        const embTag = meta.embeddingUsed ? `+emb(${meta.embeddingDocs})` : 'bm25-only';
-        if (includeCode && codeResults.length > 0) {
-            console.log(`Search: "${q}" (${wikiResults.length} wiki + ${codeResults.length} code results, ${embTag})`);
+        // Default / --all / --wiki-only: mixed interleaved results
+        const merged = mergeAndNormalize(wikiResults, codeResults, limit, q);
+        const wikiCount = merged.filter(r => r.source === 'wiki').length;
+        const codeCount = merged.filter(r => r.source === 'code').length;
+        if (opts.json) {
+            const typeCountsJson = {};
+            for (const r of merged) {
+                let dt;
+                if (r.source === 'code')
+                    dt = 'code';
+                else if (r.category === 'session')
+                    dt = 'session';
+                else if (r.category === 'scratch')
+                    dt = 'scratch';
+                else
+                    dt = r.kind;
+                typeCountsJson[dt] = (typeCountsJson[dt] ?? 0) + 1;
+            }
+            console.log(JSON.stringify({ query: q, wikiCount, codeCount, typeCounts: typeCountsJson, count: merged.length, results: merged }, null, 2));
+            return;
         }
-        else {
-            console.log(`Search: "${q}" (${wikiResults.length} results, ${embTag})`);
+        // Per-type breakdown header
+        const TYPE_DISPLAY_ORDER = ['spec', 'domain', 'knowhow', 'issue', 'project', 'roadmap', 'note', 'session', 'scratch', 'code'];
+        const typeCounts = new Map();
+        for (const r of merged) {
+            let displayType;
+            if (r.source === 'code')
+                displayType = 'code';
+            else if (r.category === 'session')
+                displayType = 'session';
+            else if (r.category === 'scratch')
+                displayType = 'scratch';
+            else
+                displayType = r.kind;
+            typeCounts.set(displayType, (typeCounts.get(displayType) ?? 0) + 1);
+        }
+        const countParts = [];
+        for (const t of TYPE_DISPLAY_ORDER) {
+            const c = typeCounts.get(t);
+            if (c)
+                countParts.push(`${t} ${c}`);
+        }
+        for (const [t, c] of typeCounts) {
+            if (!TYPE_DISPLAY_ORDER.includes(t))
+                countParts.push(`${t} ${c}`);
         }
+        const countSummary = countParts.length > 0
+            ? `${countParts.join(' + ')} = ${merged.length} results`
+            : '0 results';
+        console.log(`Search: "${q}" (${countSummary}, ${embTag})`);
         if (qTerms.length > 4) {
-            console.log(`  Hint: ${qTerms.length} terms detected — split into 1-3 keyword queries for better precision`);
+            console.log(`  Hint: ${qTerms.length} terms — split into 1-3 keyword queries for better precision`);
         }
-        if (wikiResults.length === 0 && codeResults.length === 0) {
+        if (merged.length === 0) {
             console.log('  No matches found.');
             return;
         }
-        if (wikiResults.length > 0) {
-            if (includeCode)
-                console.log('  [Wiki Results]');
-            for (const r of wikiResults) {
-                const indent = includeCode ? '    ' : '  ';
-                const typeTag = `[${r.type}]`;
-                const catTag = r.category ? ` ${r.category}` : '';
-                const wsTag = r.workspace ? ` [ws:${r.workspace}]` : '';
-                const scoreTag = r.score !== null ? `  (${r.score.toFixed(4)})` : '';
-                const title = isTTY ? highlightTerms(r.title, qTerms) : r.title;
-                console.log(`${indent}${typeTag}${catTag}${wsTag}  ${r.id}  ${title}${scoreTag}`);
-                if (r.snippet) {
-                    const snippet = isTTY ? highlightTerms(r.snippet, qTerms) : r.snippet;
-                    console.log(`${indent}  ${snippet}`);
-                }
-                else if (r.summary) {
-                    const summary = isTTY ? highlightTerms(truncate(r.summary, 80), qTerms) : truncate(r.summary, 80);
-                    console.log(`${indent}  ${summary}`);
+        for (const r of merged) {
+            const displayName = truncate(r.name, 60);
+            const name = isTTY ? highlightTerms(displayName, qTerms) : displayName;
+            const scoreTag = `  (${r.normalizedScore.toFixed(4)})`;
+            if (r.source === 'wiki') {
+                console.log(`  [wiki:${r.kind}]  ${name}  ${r.detail}${scoreTag}`);
+                const subtitle = pickSubtitle(r);
+                if (subtitle) {
+                    const text = isTTY ? highlightTerms(subtitle, qTerms) : subtitle;
+                    console.log(`    ${text}`);
                 }
             }
+            else {
+                const sigTag = r.signature ? `  ${truncate(r.signature, 60)}` : '';
+                console.log(`  [code:${r.kind}]  ${name}  ${r.detail}${sigTag}${scoreTag}`);
+            }
         }
-        if (codeResults.length > 0) {
-            console.log('  [Code Results]');
-            for (const r of codeResults) {
-                const scoreTag = r.score !== null ? `  (${r.score.toFixed(4)})` : '';
-                const name = isTTY ? highlightTerms(r.name, qTerms) : r.name;
-                console.log(`    [${r.kind}] ${name}  ${r.filePath}${scoreTag}`);
+    });
+    // ── Search daemon management ───────────────────────────────────────────
+    program
+        .command('search-daemon')
+        .description('Manage the resident search daemon (warm ONNX model)')
+        .argument('<action>', 'start | stop | status')
+        .action(async (action) => {
+        const workflowRoot = resolve('.workflow');
+        if (action === 'start' || action === 'start-daemon') {
+            const info = readDaemonInfo(workflowRoot);
+            if (info && isDaemonAlive(info)) {
+                console.log(`Search daemon already running (pid=${info.pid}, port=${info.port})`);
+                return;
             }
+            console.log('Starting search daemon...');
+            const projectPath = process.cwd();
+            const wsConfig = loadWorkspaceConfig(projectPath);
+            const resolved = resolveWorkspaceLinks(projectPath, wsConfig);
+            const linkedWorkspaces = resolved
+                .filter(lw => lw.valid)
+                .map(lw => ({ name: lw.name, workflowRoot: lw.workflowRoot, shareTypes: lw.share }));
+            const { startDaemon } = await import('../search/daemon.js');
+            const { port } = await startDaemon(workflowRoot, { workflowRoot, linkedWorkspaces });
+            console.log(`Search daemon started (pid=${process.pid}, port=${port})`);
+            // Keep process alive
+            return;
+        }
+        if (action === 'stop') {
+            const stopped = stopDaemon(workflowRoot);
+            console.log(stopped ? 'Search daemon stopped.' : 'No daemon running.');
+            return;
+        }
+        if (action === 'status') {
+            const info = readDaemonInfo(workflowRoot);
+            if (!info) {
+                console.log('Search daemon: not running');
+                return;
+            }
+            const alive = isDaemonAlive(info);
+            console.log(`Search daemon: ${alive ? 'running' : 'stale (pid dead)'}  pid=${info.pid}  port=${info.port}  started=${info.startedAt}`);
+            if (!alive)
+                try {
+                    const { unlinkSync } = await import('node:fs');
+                    unlinkSync(getDaemonPath(workflowRoot));
+                }
+                catch { }
+            return;
+        }
+        console.error(`Unknown action: ${action}. Use: start, stop, status`);
+    });
+    // Hidden flag for hook-spawned daemon startup
+    program
+        .command('search-start-daemon', { hidden: true })
+        .action(async () => {
+        const workflowRoot = resolve('.workflow');
+        const projectPath = process.cwd();
+        const wsConfig = loadWorkspaceConfig(projectPath);
+        const resolved = resolveWorkspaceLinks(projectPath, wsConfig);
+        const linkedWorkspaces = resolved
+            .filter(lw => lw.valid)
+            .map(lw => ({ name: lw.name, workflowRoot: lw.workflowRoot, shareTypes: lw.share }));
+        try {
+            const { startDaemon } = await import('../search/daemon.js');
+            await startDaemon(workflowRoot, { workflowRoot, linkedWorkspaces });
+        }
+        catch {
+            process.exit(0);
         }
     });
     program
@@ -291,45 +492,172 @@ export function registerSearchCommand(program) {
         process.exit(1);
     });
 }
-function getMinMax(scores) {
-    let min = Infinity;
-    let max = -Infinity;
-    for (const s of scores) {
-        if (s < min)
-            min = s;
-        if (s > max)
-            max = s;
+// ── Display helpers ──────────────────────────────────────────────────
+function isDuplicate(text, title) {
+    const a = text.replace(/^#+\s+/, '').replace(/^[-*]\s+/, '').trim();
+    const b = title.trim();
+    if (!a || !b)
+        return true;
+    if (a === b)
+        return true;
+    if (a.startsWith(b.slice(0, 30)) || b.startsWith(a.slice(0, 30)))
+        return true;
+    return false;
+}
+function pickSubtitle(r) {
+    if (r.snippet) {
+        const content = r.snippet.replace(/^L\d+:\s*/, '');
+        if (!isDuplicate(content, r.name))
+            return r.snippet;
+    }
+    if (r.summary) {
+        const cleaned = r.summary.replace(/^#+\s+/, '').trim();
+        if (!isDuplicate(cleaned, r.name))
+            return truncate(cleaned, 80);
     }
-    return { min, max };
+    return null;
 }
-function mergeAndNormalize(wiki, code, limit) {
-    const WIKI_WEIGHT = 0.6;
-    const CODE_WEIGHT = 0.4;
-    const wikiScores = wiki.map(r => r.score ?? 0);
-    const codeScores = code.map(r => r.score ?? 0);
-    const wikiMM = wikiScores.length > 0 ? getMinMax(wikiScores) : { min: 0, max: 0 };
-    const codeMM = codeScores.length > 0 ? getMinMax(codeScores) : { min: 0, max: 0 };
-    const wikiRange = wikiMM.max - wikiMM.min || 1;
-    const codeRange = codeMM.max - codeMM.min || 1;
-    const merged = [];
-    for (const r of wiki) {
+function printCodeResult(r, indent, isTTY, qTerms) {
+    const scoreTag = r.score !== null ? `  (${r.score.toFixed(4)})` : '';
+    const name = isTTY ? highlightTerms(r.name, qTerms) : r.name;
+    const sigTag = r.signature ? `  ${truncate(r.signature, 60)}` : '';
+    console.log(`${indent}[${r.kind}] ${name}  ${r.filePath}${sigTag}${scoreTag}`);
+}
+const WIKI_TYPE_BOOST = {
+    spec: 1.15,
+    domain: 1.10,
+    knowhow: 1.05,
+    project: 0.95,
+    roadmap: 0.95,
+    issue: 0.85,
+    note: 0.80,
+};
+const CODE_KIND_BOOST = {
+    class: 1.20,
+    interface: 1.15,
+    function: 1.10,
+    method: 1.10,
+    component: 1.08,
+    route: 1.12,
+    type_alias: 1.05,
+    enum: 1.05,
+    constant: 1.00,
+    variable: 0.90,
+    field: 0.85,
+    property: 0.80,
+};
+function isCodeIdentifier(query) {
+    const trimmed = query.trim();
+    if (/^[a-z]+[A-Z]/.test(trimmed))
+        return true;
+    if (/^[A-Z][a-z]+[A-Z]/.test(trimmed))
+        return true;
+    if (/^[A-Z]{2,}[a-z]/.test(trimmed))
+        return true;
+    if (/^[a-z]+_[a-z]+/.test(trimmed))
+        return true;
+    if (/^[A-Z][a-zA-Z]+$/.test(trimmed) && !trimmed.includes(' '))
+        return true;
+    return false;
+}
+function splitCamelSnake(s) {
+    return s
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[\s_\-.]+/)
+        .map(t => t.toLowerCase())
+        .filter(t => t.length > 0);
+}
+function codeNameMatchBonus(codeName, query) {
+    const nameLower = codeName.toLowerCase();
+    const queryLower = query.toLowerCase().trim();
+    if (!queryLower)
+        return 0;
+    if (nameLower === queryLower)
+        return 50;
+    if (nameLower.startsWith(queryLower))
+        return 30;
+    if (queryLower.startsWith(nameLower))
+        return 20;
+    if (nameLower.includes(queryLower) || queryLower.includes(nameLower))
+        return 10;
+    const queryTokens = splitCamelSnake(query);
+    const nameTokens = splitCamelSnake(codeName);
+    if (queryTokens.length === 0)
+        return 0;
+    const matched = queryTokens.filter(qt => nameTokens.some(nt => nt.includes(qt) || qt.includes(nt)));
+    if (matched.length === queryTokens.length)
+        return 15 + 5 * matched.length;
+    if (matched.length > 0)
+        return 5 * matched.length;
+    return 0;
+}
+function rankNormalize(items) {
+    if (items.length === 0)
+        return [];
+    const n = items.length;
+    const sorted = [...items].sort((a, b) => b.score - a.score);
+    const result = new Array(n);
+    let i = 0;
+    while (i < n) {
+        let j = i;
+        while (j < n - 1 && sorted[j + 1].score === sorted[j].score)
+            j++;
+        const avgRank = (i + j) / 2;
+        const normalizedRank = 1 - avgRank / n;
+        for (let k = i; k <= j; k++) {
+            result[sorted[k].index] = normalizedRank;
+        }
+        i = j + 1;
+    }
+    return result;
+}
+function mergeAndNormalize(wiki, code, limit, query) {
+    const q = query ?? '';
+    const isIdQuery = isCodeIdentifier(q);
+    const hasStrongCodeMatch = code.length > 0 && code.some(r => codeNameMatchBonus(r.name, q) >= 15);
+    const WIKI_WEIGHT = isIdQuery ? 0.4 : hasStrongCodeMatch ? 0.5 : 0.6;
+    const CODE_WEIGHT = isIdQuery ? 0.6 : hasStrongCodeMatch ? 0.5 : 0.4;
+    const codeNames = new Set(code.map(r => r.name.toLowerCase()));
+    const wikiScored = wiki.map((r, i) => {
         const raw = r.score ?? 0;
+        let typeBoost = WIKI_TYPE_BOOST[r.type] ?? 1.0;
+        if (r.id.startsWith('kg-') && codeNames.has(r.title.toLowerCase())) {
+            typeBoost *= 0.7;
+        }
+        return { ...r, finalScore: raw * typeBoost, index: i };
+    });
+    const codeScored = code.map((r, i) => {
+        const raw = r.score ?? 0;
+        const kindBoost = CODE_KIND_BOOST[r.kind] ?? 1.0;
+        const nameBonus = codeNameMatchBonus(r.name, q);
+        return { ...r, finalScore: raw * kindBoost + nameBonus, index: i };
+    });
+    const wikiRanks = rankNormalize(wikiScored.map(r => ({ index: r.index, score: r.finalScore })));
+    const codeRanks = rankNormalize(codeScored.map(r => ({ index: r.index, score: r.finalScore })));
+    const merged = [];
+    for (let i = 0; i < wikiScored.length; i++) {
+        const r = wikiScored[i];
         merged.push({
             source: 'wiki',
             kind: r.type,
             name: r.title,
             detail: r.category ? `${r.category}  ${r.id}` : r.id,
-            normalizedScore: ((raw - wikiMM.min) / wikiRange) * WIKI_WEIGHT,
+            normalizedScore: wikiRanks[i] * WIKI_WEIGHT,
+            snippet: r.snippet ?? undefined,
+            summary: r.summary || undefined,
+            category: r.category ?? undefined,
         });
     }
-    for (const r of code) {
-        const raw = r.score ?? 0;
+    for (let i = 0; i < codeScored.length; i++) {
+        const r = codeScored[i];
         merged.push({
             source: 'code',
             kind: r.kind,
             name: r.name,
             detail: r.filePath,
-            normalizedScore: ((raw - codeMM.min) / codeRange) * CODE_WEIGHT,
+            normalizedScore: codeRanks[i] * CODE_WEIGHT,
+            signature: r.signature,
         });
     }
     merged.sort((a, b) => b.normalizedScore - a.normalizedScore);