maestro-flow 0.5.2 → 0.5.31

package/dashboard/dist-server/dashboard/src/server/wiki/wiki-indexer.js

@@ -21,41 +21,153 @@ import { buildInvertedIndex, searchBM25 } from './search.js';
  */
 export class WikiIndexer {
     workflowRoot;
+    linkedWorkspaces;
     cache = null;
     graphCache = null;
     searchCache = null;
     inflight = null;
+    mtimeSnapshot = new Map();
     constructor(config) {
         this.workflowRoot = resolve(config.workflowRoot);
+        this.linkedWorkspaces = (config.linkedWorkspaces ?? []).map(lw => ({
+            name: lw.name,
+            workflowRoot: resolve(lw.workflowRoot),
+            shareTypes: new Set(lw.shareTypes),
+        }));
     }
     getWorkflowRoot() {
         return this.workflowRoot;
     }
     async get() {
-        if (this.cache)
-            return this.cache;
+        if (this.cache) {
+            if (!await this.hasSourceChanges())
+                return this.cache;
+            this.cache = null;
+            this.graphCache = null;
+            this.searchCache = null;
+        }
         return this.rebuild();
     }
+    /**
+     * Quick mtime scan of known source directories. If any file's mtime
+     * changed since the last rebuild, the cache is stale.
+     */
+    async hasSourceChanges() {
+        if (this.mtimeSnapshot.size === 0)
+            return true;
+        const dirs = [
+            join(this.workflowRoot, 'specs'),
+            join(this.workflowRoot, 'knowhow'),
+            join(this.workflowRoot, 'issues'),
+            join(this.workflowRoot, 'domain'),
+            join(this.workflowRoot, 'scratch'),
+        ];
+        // Include linked workspace directories in staleness check
+        for (const lw of this.linkedWorkspaces) {
+            if (lw.shareTypes.has('spec'))
+                dirs.push(join(lw.workflowRoot, 'specs'));
+            if (lw.shareTypes.has('knowhow'))
+                dirs.push(join(lw.workflowRoot, 'knowhow'));
+            if (lw.shareTypes.has('domain'))
+                dirs.push(join(lw.workflowRoot, 'domain'));
+            if (lw.shareTypes.has('codebase'))
+                dirs.push(join(lw.workflowRoot, 'codebase'));
+        }
+        const singletons = ['project.md', 'roadmap.md'];
+        for (const s of singletons) {
+            const p = join(this.workflowRoot, s);
+            try {
+                const st = await stat(p);
+                const prev = this.mtimeSnapshot.get(p);
+                if (prev === undefined || st.mtimeMs !== prev)
+                    return true;
+            }
+            catch {
+                if (this.mtimeSnapshot.has(p))
+                    return true;
+            }
+        }
+        for (const dir of dirs) {
+            try {
+                const st = await stat(dir);
+                const prev = this.mtimeSnapshot.get(dir);
+                if (prev === undefined || st.mtimeMs !== prev)
+                    return true;
+            }
+            catch {
+                if (this.mtimeSnapshot.has(dir))
+                    return true;
+            }
+        }
+        return false;
+    }
+    async captureMtimeSnapshot() {
+        const snap = new Map();
+        const dirs = [
+            join(this.workflowRoot, 'specs'),
+            join(this.workflowRoot, 'knowhow'),
+            join(this.workflowRoot, 'issues'),
+            join(this.workflowRoot, 'domain'),
+            join(this.workflowRoot, 'scratch'),
+        ];
+        for (const lw of this.linkedWorkspaces) {
+            if (lw.shareTypes.has('spec'))
+                dirs.push(join(lw.workflowRoot, 'specs'));
+            if (lw.shareTypes.has('knowhow'))
+                dirs.push(join(lw.workflowRoot, 'knowhow'));
+            if (lw.shareTypes.has('domain'))
+                dirs.push(join(lw.workflowRoot, 'domain'));
+            if (lw.shareTypes.has('codebase'))
+                dirs.push(join(lw.workflowRoot, 'codebase'));
+        }
+        const singletons = ['project.md', 'roadmap.md'];
+        for (const s of singletons) {
+            const p = join(this.workflowRoot, s);
+            try {
+                snap.set(p, (await stat(p)).mtimeMs);
+            }
+            catch { /* missing is fine */ }
+        }
+        for (const dir of dirs) {
+            try {
+                snap.set(dir, (await stat(dir)).mtimeMs);
+            }
+            catch { /* missing */ }
+        }
+        return snap;
+    }
     async rebuild() {
         if (this.inflight)
             return this.inflight;
         this.inflight = (async () => {
             const fileEntries = await this.scanFiles();
             const virtualEntries = await this.scanVirtual();
-            const entries = [...fileEntries, ...virtualEntries];
+            const linkedEntries = await this.scanLinkedWorkspaces();
+            const entries = [...fileEntries, ...virtualEntries, ...linkedEntries];
             // Stable collision suffix — use original id for counting so the
             // third duplicate becomes -3 (not another -2).
+            // Collisions are expected across multi-source JSONL files; warn only
+            // when MAESTRO_DEBUG is set to avoid polluting CLI search output.
             const seen = new Map();
+            const debugCollisions = process.env.MAESTRO_DEBUG === '1';
+            let collisionCount = 0;
             for (const d of entries) {
                 const original = d.id;
                 const n = seen.get(original) ?? 0;
                 if (n > 0) {
-                    // eslint-disable-next-line no-console
-                    console.warn(`[wiki-indexer] id collision '${original}' — suffixing`);
+                    if (debugCollisions) {
+                        // eslint-disable-next-line no-console
+                        console.warn(`[wiki-indexer] id collision '${original}' — suffixing to ${original}-${n + 1}`);
+                    }
                     d.id = `${original}-${n + 1}`;
+                    collisionCount++;
                 }
                 seen.set(original, n + 1);
             }
+            if (collisionCount > 0 && debugCollisions) {
+                // eslint-disable-next-line no-console
+                console.warn(`[wiki-indexer] ${collisionCount} id collision(s) resolved by suffixing`);
+            }
             const byId = {};
             const byType = {
                 project: [],
@@ -64,6 +176,7 @@ export class WikiIndexer {
                 issue: [],
                 knowhow: [],
                 note: [],
+                domain: [],
             };
             for (const d of entries) {
                 byId[d.id] = d;
@@ -80,6 +193,8 @@ export class WikiIndexer {
             this.cache = index;
             this.graphCache = null;
             this.searchCache = null;
+            // Snapshot mtimes of source directories for incremental staleness check
+            this.mtimeSnapshot = await this.captureMtimeSnapshot();
             // Persist lightweight index to disk (fire-and-forget).
             this.persistIndex(index).catch(() => { });
             return index;
@@ -122,6 +237,7 @@ export class WikiIndexer {
             issue: [],
             knowhow: [],
             note: [],
+            domain: [],
         };
         for (const d of source)
             out[d.type].push(d);
@@ -141,13 +257,20 @@ export class WikiIndexer {
         this.searchCache = buildInvertedIndex(index.entries);
         return this.searchCache;
     }
-    async search(query, limit = 50) {
+    async searchWithScores(query, limit = 50) {
         const index = await this.get();
         const bm25 = await this.getSearchIndex();
         const ranked = searchBM25(bm25, query, limit);
-        return ranked
-            .map((r) => index.byId[r.docId])
-            .filter((d) => Boolean(d));
+        const out = [];
+        for (const r of ranked) {
+            const entry = index.byId[r.docId];
+            if (entry)
+                out.push({ entry, score: r.score });
+        }
+        return out;
+    }
+    async search(query, limit = 50) {
+        return (await this.searchWithScores(query, limit)).map(r => r.entry);
     }
     // -------------------------------------------------------------------------
     // Walk
@@ -214,11 +337,9 @@ export class WikiIndexer {
                 }
             }
         }
-        // knowhow/*.md  (KNW-→session, TIP-→tip, TPL-→template, RCP-→recipe, REF-→reference, DCS-→decision, DOC-→document)
-        for (const name of await safeReaddir(join(this.workflowRoot, 'knowhow'))) {
-            if (extname(name).toLowerCase() !== '.md')
-                continue;
-            const entry = await this.parseFileEntry(join(this.workflowRoot, 'knowhow', name), 'knowhow');
+        // knowhow/*.md — recursive scan supports both flat and sub-folder layouts
+        const knowhowEntries = await this.scanKnowhowDir(join(this.workflowRoot, 'knowhow'));
+        for (const { name, absPath, entry } of knowhowEntries) {
             if (entry) {
                 // Only derive category from file prefix if no frontmatter category
                 if (!entry.category) {
@@ -278,8 +399,139 @@ export class WikiIndexer {
                 }
             }
         }
+        // domain/glossary.json → domain WikiEntries
+        const domainEntries = await this.scanDomain();
+        out.push(...domainEntries);
+        // scratch/*/*.md — session working documents (lowest search priority via SCRATCH_FIELD_CONFIGS)
+        const scratchEntries = await this.scanScratchDocuments();
+        out.push(...scratchEntries);
+        return out;
+    }
+    /**
+     * Recursively scan knowhow directory (supports both flat and sub-folder layouts).
+     */
+    async scanKnowhowDir(dir) {
+        const results = [];
+        for (const name of await safeReaddir(dir)) {
+            const fullPath = join(dir, name);
+            let stats = null;
+            try {
+                stats = await stat(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                const nested = await this.scanKnowhowDir(fullPath);
+                results.push(...nested);
+            }
+            else if (stats.isFile() && extname(name).toLowerCase() === '.md') {
+                const entry = await this.parseFileEntry(fullPath, 'knowhow');
+                results.push({ name, absPath: fullPath, entry });
+            }
+        }
+        return results;
+    }
+    /**
+     * Scan .workflow/scratch session directories for .md working documents.
+     * These are indexed as 'note' type with ext.virtualKind='scratch-doc'
+     * so search.ts applies SCRATCH_FIELD_CONFIGS (lowest BM25 weight).
+     */
+    async scanScratchDocuments() {
+        const scratchRoot = join(this.workflowRoot, 'scratch');
+        if (!existsSync(scratchRoot))
+            return [];
+        const out = [];
+        for (const sessionName of await safeReaddir(scratchRoot)) {
+            const sessionDir = join(scratchRoot, sessionName);
+            let dirStat = null;
+            try {
+                dirStat = await stat(sessionDir);
+            }
+            catch {
+                continue;
+            }
+            if (!dirStat.isDirectory())
+                continue;
+            for (const fileName of await safeReaddir(sessionDir)) {
+                if (extname(fileName).toLowerCase() !== '.md')
+                    continue;
+                const absPath = join(sessionDir, fileName);
+                const entry = await this.parseFileEntry(absPath, 'note');
+                if (!entry)
+                    continue;
+                const stem = basename(fileName, extname(fileName));
+                entry.id = `scratch-${slugify(sessionName)}-${slugify(stem)}`;
+                entry.ext = { ...entry.ext, virtualKind: 'scratch-doc', sessionDir: sessionName };
+                entry.category = entry.category || 'scratch';
+                out.push(entry);
+            }
+        }
         return out;
     }
+    /**
+     * Scan .workflow/domain/glossary.json and produce WikiEntry[] for each term.
+     */
+    async scanDomain() {
+        const glossaryPath = join(this.workflowRoot, 'domain', 'glossary.json');
+        try {
+            const raw = await readFile(glossaryPath, 'utf-8');
+            const glossary = JSON.parse(raw);
+            if (!Array.isArray(glossary.terms))
+                return [];
+            const now = new Date().toISOString();
+            let glossaryStat;
+            try {
+                glossaryStat = await stat(glossaryPath);
+            }
+            catch {
+                return [];
+            }
+            const fileDate = new Date(glossaryStat.mtimeMs).toISOString();
+            return glossary.terms.map((term) => {
+                const id = term.id;
+                const canonical = term.canonical;
+                const definition = term.definition ?? '';
+                const aliases = term.aliases ?? [];
+                const keywords = term.keywords ?? [];
+                const relationships = term.relationships ?? [];
+                const status = (term.status ?? 'active') === 'active' ? 'active' : 'archived';
+                const bodyLines = [`# ${canonical}`, '', definition, ''];
+                if (aliases.length)
+                    bodyLines.push(`Aliases: ${aliases.join(', ')}`);
+                if (relationships.length)
+                    bodyLines.push(`Related: ${relationships.join(', ')}`);
+                if (keywords.length)
+                    bodyLines.push(`Keywords: ${keywords.join(', ')}`);
+                return {
+                    id: `domain-${id}`,
+                    type: 'domain',
+                    title: canonical,
+                    summary: definition,
+                    tags: [...aliases, ...keywords],
+                    status: status,
+                    created: fileDate,
+                    updated: fileDate,
+                    related: relationships.map(r => `domain-${r}`),
+                    source: { kind: 'file', path: 'domain/glossary.json' },
+                    body: bodyLines.join('\n'),
+                    ext: {
+                        tier: term.tier ?? 'core',
+                        sourceKind: term.source?.kind ?? 'unknown',
+                    },
+                    scope: null,
+                    category: 'domain',
+                    specCategory: null,
+                    createdBy: null,
+                    sourceRef: null,
+                    parent: null,
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
     /**
      * Resolve spec directories for all scopes that exist on disk.
      * Returns entries with scoped ID prefix and source path prefix.
@@ -341,6 +593,11 @@ export class WikiIndexer {
     }
     async scanVirtual() {
         const out = [];
+        // Issues: collect from all JSONL files, then deduplicate by ID keeping the
+        // entry with the most recent updated timestamp.  This avoids collision
+        // warnings when the same issue ID appears across multiple JSONL sources
+        // (e.g. issues.jsonl and review-issues.jsonl).
+        const allIssues = [];
         for (const name of await safeReaddir(join(this.workflowRoot, 'issues'))) {
             if (extname(name).toLowerCase() !== '.jsonl')
                 continue;
@@ -348,8 +605,16 @@ export class WikiIndexer {
             if (!this.isInsideRoot(abs))
                 continue;
             const rel = toForwardSlash(relative(this.workflowRoot, abs));
-            out.push(...(await loadVirtualEntries(abs, adaptIssueRow, rel)));
+            allIssues.push(...(await loadVirtualEntries(abs, adaptIssueRow, rel)));
         }
+        const issueBest = new Map();
+        for (const e of allIssues) {
+            const existing = issueBest.get(e.id);
+            if (!existing || e.updated > existing.updated) {
+                issueBest.set(e.id, e);
+            }
+        }
+        out.push(...issueBest.values());
         // Codebase: .workflow/codebase/doc-index.json → component/feature/req/ADR
         const codebaseIndex = join(this.workflowRoot, 'codebase', 'doc-index.json');
         if (existsSync(codebaseIndex) && this.isInsideRoot(codebaseIndex)) {
@@ -395,6 +660,279 @@ export class WikiIndexer {
         }
         return out;
     }
+    // -------------------------------------------------------------------------
+    // Linked workspace scanning
+    // -------------------------------------------------------------------------
+    async scanLinkedWorkspaces() {
+        const out = [];
+        for (const lw of this.linkedWorkspaces) {
+            if (!existsSync(lw.workflowRoot)) {
+                if (process.env.MAESTRO_DEBUG === '1') {
+                    // eslint-disable-next-line no-console
+                    console.warn(`[wiki-indexer] linked workspace "${lw.name}" not found: ${lw.workflowRoot}`);
+                }
+                continue;
+            }
+            const entries = await this.scanLinkedWorkspace(lw);
+            out.push(...entries);
+        }
+        return out;
+    }
+    async scanLinkedWorkspace(lw) {
+        const out = [];
+        const idPrefix = `ws:${lw.name}:`;
+        if (lw.shareTypes.has('spec')) {
+            const specsDir = join(lw.workflowRoot, 'specs');
+            for (const name of await safeReaddir(specsDir)) {
+                if (extname(name).toLowerCase() !== '.md')
+                    continue;
+                const absPath = join(specsDir, name);
+                const entry = await this.parseLinkedFileEntry(absPath, 'spec', lw.name, lw.workflowRoot);
+                if (!entry)
+                    continue;
+                const stem = basename(name, extname(name));
+                entry.id = `${idPrefix}spec:${slugify(stem)}`;
+                entry.scope = 'linked';
+                entry.source = { kind: 'file', path: `specs/${name}`, workspace: lw.name };
+                out.push(entry);
+                const specEntries = parseSpecEntries(entry.body, name, {
+                    category: entry.category ?? undefined,
+                    keywords: entry.tags,
+                });
+                for (const se of specEntries) {
+                    out.push({
+                        id: `${idPrefix}spec:${se.id}`,
+                        type: 'spec',
+                        title: se.title,
+                        summary: se.description || se.content.slice(0, 240).replace(/\s+/g, ' '),
+                        tags: se.keywords,
+                        status: 'active',
+                        created: entry.created,
+                        updated: entry.updated,
+                        related: [],
+                        source: { kind: 'file', path: `specs/${name}`, workspace: lw.name },
+                        body: se.content,
+                        ext: { entryType: se.type, timestamp: se.timestamp },
+                        scope: 'linked',
+                        category: se.category || entry.category,
+                        specCategory: entry.specCategory,
+                        createdBy: entry.createdBy,
+                        sourceRef: entry.sourceRef,
+                        parent: entry.id,
+                    });
+                }
+            }
+        }
+        if (lw.shareTypes.has('knowhow')) {
+            const knowhowDir = join(lw.workflowRoot, 'knowhow');
+            const knowhowFiles = await this.scanLinkedKnowhowDir(knowhowDir, lw.name, lw.workflowRoot);
+            for (const { entry } of knowhowFiles) {
+                if (!entry)
+                    continue;
+                entry.id = `${idPrefix}${entry.id}`;
+                entry.scope = 'linked';
+                out.push(entry);
+            }
+        }
+        if (lw.shareTypes.has('domain')) {
+            const domainEntries = await this.scanLinkedDomain(lw.workflowRoot, lw.name);
+            for (const e of domainEntries) {
+                e.id = `${idPrefix}${e.id}`;
+                out.push(e);
+            }
+        }
+        if (lw.shareTypes.has('codebase')) {
+            const codebaseIndex = join(lw.workflowRoot, 'codebase', 'doc-index.json');
+            if (existsSync(codebaseIndex)) {
+                const rel = `codebase/doc-index.json`;
+                const entries = await loadVirtualJsonEntries(codebaseIndex, adaptCodebaseDocIndex, rel);
+                for (const e of entries) {
+                    e.id = `${idPrefix}${e.id}`;
+                    e.source = { ...e.source, workspace: lw.name };
+                    e.scope = 'linked';
+                    out.push(e);
+                }
+            }
+            const kgPath = join(lw.workflowRoot, 'codebase', 'knowledge-graph.json');
+            if (existsSync(kgPath)) {
+                const kgRel = `codebase/knowledge-graph.json`;
+                const kgEntries = await loadVirtualJsonEntries(kgPath, adaptKnowledgeGraph, kgRel);
+                for (const e of kgEntries) {
+                    e.id = `${idPrefix}${e.id}`;
+                    e.source = { ...e.source, workspace: lw.name };
+                    e.scope = 'linked';
+                    out.push(e);
+                }
+            }
+        }
+        return out;
+    }
+    async parseLinkedFileEntry(absPath, type, wsName, wsWorkflowRoot) {
+        const requested = resolve(absPath);
+        const root = resolve(wsWorkflowRoot);
+        if (!requested.startsWith(root + sep) && requested !== root)
+            return null;
+        try {
+            const ls = await lstat(absPath);
+            if (ls.isSymbolicLink() || !ls.isFile())
+                return null;
+        }
+        catch {
+            return null;
+        }
+        let raw;
+        let stats;
+        try {
+            raw = await readFile(absPath, 'utf-8');
+            stats = await stat(absPath);
+        }
+        catch {
+            return null;
+        }
+        const { data, content } = parseFrontmatter(raw);
+        const fileName = basename(absPath);
+        const stem = basename(fileName, extname(fileName));
+        const title = asString(data.title) || firstHeading(content) || stem;
+        const summary = asString(data.description) || asString(data.summary) || firstParagraph(content);
+        const tags = extractTags(data);
+        const status = asStatus(data.status) ?? inferStatus(type);
+        const related = normalizeRelated(data.related);
+        const ext = extractExt(data);
+        const category = asString(data.category) || null;
+        const specCategory = asString(data.specCategory) || null;
+        const createdBy = asString(data.createdBy) || null;
+        const sourceRef = asString(data.sourceRef) || null;
+        const parent = asString(data.parent) || null;
+        const rel = toForwardSlash(relative(wsWorkflowRoot, absPath));
+        const id = `${type}-${slugify(stem)}`;
+        return {
+            id,
+            type,
+            title,
+            summary,
+            tags,
+            status,
+            created: new Date(stats.birthtimeMs || stats.mtimeMs).toISOString(),
+            updated: new Date(stats.mtimeMs).toISOString(),
+            related,
+            source: { kind: 'file', path: rel, workspace: wsName },
+            body: content,
+            ext,
+            scope: 'linked',
+            category,
+            specCategory,
+            createdBy,
+            sourceRef,
+            parent,
+        };
+    }
+    async scanLinkedKnowhowDir(dir, wsName, wsWorkflowRoot) {
+        const results = [];
+        for (const name of await safeReaddir(dir)) {
+            const fullPath = join(dir, name);
+            let stats = null;
+            try {
+                stats = await stat(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                const nested = await this.scanLinkedKnowhowDir(fullPath, wsName, wsWorkflowRoot);
+                results.push(...nested);
+            }
+            else if (stats.isFile() && extname(name).toLowerCase() === '.md') {
+                const entry = await this.parseLinkedFileEntry(fullPath, 'knowhow', wsName, wsWorkflowRoot);
+                if (entry) {
+                    if (!entry.category) {
+                        const upper = name.toUpperCase();
+                        if (upper.startsWith('KNW-'))
+                            entry.category = 'session';
+                        else if (upper.startsWith('TPL-'))
+                            entry.category = 'template';
+                        else if (upper.startsWith('RCP-'))
+                            entry.category = 'recipe';
+                        else if (upper.startsWith('REF-'))
+                            entry.category = 'reference';
+                        else if (upper.startsWith('DCS-'))
+                            entry.category = 'decision';
+                        else if (upper.startsWith('TIP-'))
+                            entry.category = 'tip';
+                        else if (upper.startsWith('AST-'))
+                            entry.category = 'asset';
+                        else if (upper.startsWith('BLP-'))
+                            entry.category = 'blueprint';
+                        else if (upper.startsWith('DOC-'))
+                            entry.category = 'document';
+                    }
+                }
+                results.push({ entry });
+            }
+        }
+        return results;
+    }
+    async scanLinkedDomain(wsWorkflowRoot, wsName) {
+        const glossaryPath = join(wsWorkflowRoot, 'domain', 'glossary.json');
+        try {
+            const raw = await readFile(glossaryPath, 'utf-8');
+            const glossary = JSON.parse(raw);
+            if (!Array.isArray(glossary.terms))
+                return [];
+            let glossaryStat;
+            try {
+                glossaryStat = await stat(glossaryPath);
+            }
+            catch {
+                return [];
+            }
+            const fileDate = new Date(glossaryStat.mtimeMs).toISOString();
+            return glossary.terms.map((term) => {
+                const id = term.id;
+                const canonical = term.canonical;
+                const definition = term.definition ?? '';
+                const aliases = term.aliases ?? [];
+                const keywords = term.keywords ?? [];
+                const relationships = term.relationships ?? [];
+                const status = (term.status ?? 'active') === 'active' ? 'active' : 'archived';
+                const bodyLines = [`# ${canonical}`, '', definition, ''];
+                if (aliases.length)
+                    bodyLines.push(`Aliases: ${aliases.join(', ')}`);
+                if (relationships.length)
+                    bodyLines.push(`Related: ${relationships.join(', ')}`);
+                if (keywords.length)
+                    bodyLines.push(`Keywords: ${keywords.join(', ')}`);
+                return {
+                    id: `domain-${id}`,
+                    type: 'domain',
+                    title: canonical,
+                    summary: definition,
+                    tags: [...aliases, ...keywords],
+                    status: status,
+                    created: fileDate,
+                    updated: fileDate,
+                    related: relationships.map(r => `domain-${r}`),
+                    source: { kind: 'file', path: 'domain/glossary.json', workspace: wsName },
+                    body: bodyLines.join('\n'),
+                    ext: {
+                        tier: term.tier ?? 'core',
+                        sourceKind: term.source?.kind ?? 'unknown',
+                    },
+                    scope: 'linked',
+                    category: 'domain',
+                    specCategory: null,
+                    createdBy: null,
+                    sourceRef: null,
+                    parent: null,
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    // -------------------------------------------------------------------------
+    // File parsing
+    // -------------------------------------------------------------------------
     async parseFileEntry(absPath, type) {
         if (!this.isInsideRoot(absPath))
             return null;
@@ -433,13 +971,11 @@ export class WikiIndexer {
         const sourceRef = asString(data.sourceRef) || null;
         const parent = asString(data.parent) || null;
         const rel = toForwardSlash(relative(this.workflowRoot, absPath));
-        // Knowhow files live under knowhow/ with prefix-<slug>.md naming.
-        // Strip the 4-char prefix (KNW-/TIP-/TPL-/RCP-/REF-/DCS-/AST-/BLP-) from the id-generating
-        // stem so the id matches what WikiWriter produced at create time (`knowhow-<slug>`).
-        let idStem = stem;
-        if (/^(KNW|TIP|TPL|RCP|REF|DCS|AST|BLP|DOC)-/i.test(stem))
-            idStem = stem.slice(4);
-        const id = `${type}-${slugify(idStem)}`;
+        // Knowhow files use prefix-<slug>.md naming (KNW-, TIP-, TPL-, etc.).
+        // Keep the full stem (including prefix) to avoid collisions when multiple
+        // prefixed files share the same timestamp slug (e.g. KNW-20260427-1912 vs
+        // DCS-20260427-1912 both slugifying to the same value).
+        const id = `${type}-${slugify(stem)}`;
         return {
             id,
             type,
@@ -623,6 +1159,8 @@ export function filterEntries(entries, filters) {
             return false;
         if (filters.tool && d.ext?.tool !== true && d.ext?.tool !== 'true')
             return false;
+        if (filters.workspace && d.source.workspace !== filters.workspace)
+            return false;
         if (filters.q) {
             const q = filters.q.toLowerCase();
             if (!d.title.toLowerCase().includes(q) && !d.summary.toLowerCase().includes(q)) {