kibi-mcp 0.9.0 → 0.11.0

package/dist/tools/autopilot-discovery.js

@@ -6,7 +6,33 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import fg from "fast-glob";
+import * as cliSymbolCoordinator from "kibi-cli/extractors/symbols-coordinator";
 import { runJsonModuleQuery } from "./core-module.js";
+// implements REQ-001
+export const AUTOPILOT_PROVIDER_ORDER = [
+    "typed_kibi_docs",
+    "generic_repo_docs",
+    "repo_metadata",
+    "repo_layout",
+    "test_topology",
+    "source_symbols",
+];
+const IGNORED_DIRECTORY_NAMES = new Set([
+    ".git",
+    ".kb",
+    ".venv",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "target",
+    "third-party",
+    "third_party",
+    "vendor",
+    "vendors",
+    "venv",
+]);
 // Minimal copy of the opencode defaults used by other packages. Keep in sync
 // with packages/opencode/src/file-filter.ts DEFAULT_SYNC_PATHS.
 const DEFAULT_SYNC_PATHS = {
@@ -19,8 +45,51 @@ const DEFAULT_SYNC_PATHS = {
     facts: "documentation/facts/**/*.md",
     symbols: "documentation/symbols.yaml",
 };
+const SOURCE_LANGUAGE_EXTENSIONS = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".swift": "swift",
+    ".php": "php",
+    ".c": "c",
+    ".cc": "cpp",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+};
+const PROJECT_SIGNAL_FILES = [
+    "README.md",
+    "README.mdx",
+    "package.json",
+    "tsconfig.json",
+    "pyproject.toml",
+    "Cargo.toml",
+    "go.mod",
+];
+const PROJECT_SIGNAL_DIRS = [
+    "src",
+    "app",
+    "apps",
+    "packages",
+    "tests",
+    "test",
+    "docs",
+    "documentation",
+    "scripts",
+];
 function findVendoredTrees(cwd) {
-    const results = [];
+    const results = new Set();
     const vendoredMarkers = [
         ["kibi", "opencode.json"],
         ["kibi", "package.json"],
@@ -30,7 +99,7 @@ function findVendoredTrees(cwd) {
     for (const marker of vendoredMarkers) {
         const markerPath = path.join(cwd, ...marker);
         if (fs.existsSync(markerPath)) {
-            results.push(marker.join("/"));
+            results.add(marker[0] ?? "kibi");
         }
     }
     const nodeModules = path.join(cwd, "node_modules");
@@ -38,7 +107,7 @@ function findVendoredTrees(cwd) {
         try {
             for (const entry of fs.readdirSync(nodeModules)) {
                 if (entry === "kibi" || entry.startsWith("kibi-")) {
-                    results.push(`node_modules/${entry}`);
+                    results.add(`node_modules/${entry}`);
                 }
             }
         }
@@ -46,11 +115,30 @@ function findVendoredTrees(cwd) {
             // ignore
         }
     }
-    return Array.from(new Set(results));
+    return Array.from(results).sort();
 }
 function rootKbConfigExists(cwd) {
     return fs.existsSync(path.join(cwd, ".kb", "config.json"));
 }
+function hasWorkspaceProjectSignals(cwd, vendoredRoots) {
+    const vendoredTopLevel = new Set(vendoredRoots
+        .map((item) => item.split("/")[0])
+        .filter((item) => Boolean(item)));
+    for (const fileName of PROJECT_SIGNAL_FILES) {
+        if (fs.existsSync(path.join(cwd, fileName))) {
+            return true;
+        }
+    }
+    for (const dirName of PROJECT_SIGNAL_DIRS) {
+        if (vendoredTopLevel.has(dirName))
+            continue;
+        const candidate = path.join(cwd, dirName);
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            return true;
+        }
+    }
+    return false;
+}
 function readRootConfig(cwd) {
     try {
         const raw = fs.readFileSync(path.join(cwd, ".kb", "config.json"), "utf8");
@@ -80,6 +168,575 @@ function normalizePattern(p) {
         return p;
     return `${p.replace(/\/+$/, "")}/**/*.md`;
 }
+function buildSourceSummary(activation, vendored) {
+    return {
+        activationState: activation.activationState,
+        activationMode: activation.activationMode,
+        applyBlocked: activation.applyBlocked,
+        reason: activation.reason,
+        ...(activation.handoffMessage
+            ? { handoffMessage: activation.handoffMessage }
+            : {}),
+        ...(vendored.length > 0 ? { vendored } : {}),
+    };
+}
+function createEmptyProviderCounts() {
+    return Object.fromEntries(AUTOPILOT_PROVIDER_ORDER.map((provider) => [provider, 0]));
+}
+function sortUnique(values) {
+    return Array.from(new Set(values)).filter(Boolean).sort();
+}
+function toRelativePosixPath(workspaceRoot, targetPath) {
+    return path.relative(workspaceRoot, targetPath).split(path.sep).join("/");
+}
+function normalizeDiscoveryPaths(cwd) {
+    const config = readRootConfig(cwd) || {};
+    const configured = config.paths ?? {};
+    const readPath = (key) => {
+        const configuredValue = configured[key];
+        if (typeof configuredValue === "string" && configuredValue.length > 0) {
+            return configuredValue;
+        }
+        const fallbackValue = DEFAULT_SYNC_PATHS[key];
+        return typeof fallbackValue === "string" ? fallbackValue : "";
+    };
+    return {
+        requirements: readPath("requirements"),
+        scenarios: readPath("scenarios"),
+        tests: readPath("tests"),
+        adr: readPath("adr"),
+        flags: readPath("flags"),
+        events: readPath("events"),
+        facts: readPath("facts"),
+        symbols: readPath("symbols"),
+    };
+}
+function buildIgnoredGlobs(vendoredRoots) {
+    const ignored = new Set();
+    for (const dirName of IGNORED_DIRECTORY_NAMES) {
+        ignored.add(`**/${dirName}`);
+        ignored.add(`**/${dirName}/**`);
+    }
+    for (const vendoredRoot of vendoredRoots) {
+        const normalized = vendoredRoot.replace(/\\/g, "/").replace(/^\.\//, "");
+        if (!normalized)
+            continue;
+        ignored.add(normalized);
+        ignored.add(`${normalized}/**`);
+        ignored.add(`**/${normalized}`);
+        ignored.add(`**/${normalized}/**`);
+    }
+    return Array.from(ignored);
+}
+function detectLanguagesFromPaths(paths) {
+    const detected = new Set();
+    for (const filePath of paths) {
+        const language = SOURCE_LANGUAGE_EXTENSIONS[path.extname(filePath).toLowerCase()];
+        if (language) {
+            detected.add(language);
+        }
+    }
+    return Array.from(detected);
+}
+function createFileEvidence(provider, kind, workspaceRoot, absolutePath, data = {}) {
+    const relativePath = toRelativePosixPath(workspaceRoot, absolutePath);
+    return {
+        provider,
+        kind,
+        label: relativePath,
+        relativePath,
+        absolutePath,
+        data,
+    };
+}
+function runTypedKibiDocsProvider(workspaceRoot) {
+    const discoveryPaths = normalizeDiscoveryPaths(workspaceRoot);
+    const markdownPatterns = [
+        normalizePattern(discoveryPaths.requirements),
+        normalizePattern(discoveryPaths.scenarios),
+        normalizePattern(discoveryPaths.tests),
+        normalizePattern(discoveryPaths.adr),
+        normalizePattern(discoveryPaths.flags),
+        normalizePattern(discoveryPaths.events),
+        normalizePattern(discoveryPaths.facts),
+    ].filter((pattern) => Boolean(pattern));
+    const markdownFiles = fg.sync(markdownPatterns, {
+        cwd: workspaceRoot,
+        absolute: true,
+        onlyFiles: true,
+        unique: true,
+        suppressErrors: true,
+    });
+    const manifestFiles = discoveryPaths.symbols
+        ? fg.sync(discoveryPaths.symbols, {
+            cwd: workspaceRoot,
+            absolute: true,
+            onlyFiles: true,
+            unique: true,
+            suppressErrors: true,
+        })
+        : [];
+    const evidence = [
+        ...sortUnique(markdownFiles).map((absolutePath) => createFileEvidence("typed_kibi_docs", "typed_markdown", workspaceRoot, absolutePath)),
+        ...sortUnique(manifestFiles).map((absolutePath) => createFileEvidence("typed_kibi_docs", "symbol_manifest", workspaceRoot, absolutePath)),
+    ];
+    return {
+        provider: "typed_kibi_docs",
+        evidence,
+    };
+}
+function runGenericRepoDocsProvider(workspaceRoot, vendoredRoots, typedFilePaths) {
+    const markdownFiles = fg.sync("**/*.md", {
+        cwd: workspaceRoot,
+        absolute: true,
+        onlyFiles: true,
+        unique: true,
+        suppressErrors: true,
+        ignore: buildIgnoredGlobs(vendoredRoots),
+    });
+    const evidence = sortUnique(markdownFiles)
+        .map((absolutePath) => createFileEvidence("generic_repo_docs", "generic_markdown", workspaceRoot, absolutePath))
+        .filter((item) => !typedFilePaths.has(item.relativePath ?? ""));
+    return {
+        provider: "generic_repo_docs",
+        evidence,
+    };
+}
+function detectLanguagesFromPackageJson(packageJson) {
+    const detected = new Set();
+    const scripts = packageJson.scripts;
+    const bin = packageJson.bin;
+    if (typeof scripts === "object" && scripts) {
+        for (const value of Object.values(scripts)) {
+            if (typeof value === "string" && /\.(cts|mts|ts|tsx)\b|\b(tsx|ts-node)\b/i.test(value)) {
+                detected.add("typescript");
+            }
+            if (typeof value === "string" && /\.(cjs|mjs|js|jsx)\b/i.test(value)) {
+                detected.add("javascript");
+            }
+        }
+    }
+    if (typeof bin === "string" && /\.(cts|mts|ts|tsx)\b/i.test(bin)) {
+        detected.add("typescript");
+    }
+    if (typeof bin === "object" && bin) {
+        for (const value of Object.values(bin)) {
+            if (typeof value === "string" && /\.(cts|mts|ts|tsx)\b/i.test(value)) {
+                detected.add("typescript");
+            }
+        }
+    }
+    return Array.from(detected);
+}
+function runRepoMetadataProvider(workspaceRoot) {
+    const patterns = [
+        "package.json",
+        "opencode.json",
+        "tsconfig.json",
+        "tsconfig.*.json",
+        "bun.lock",
+        "bun.lockb",
+        "bunfig.toml",
+        "pnpm-workspace.yaml",
+        "pnpm-lock.yaml",
+        "package-lock.json",
+        "yarn.lock",
+        "Cargo.toml",
+        "go.mod",
+        "pyproject.toml",
+        "requirements*.txt",
+    ];
+    const metadataFiles = fg.sync(patterns, {
+        cwd: workspaceRoot,
+        absolute: true,
+        onlyFiles: true,
+        unique: true,
+        suppressErrors: true,
+    });
+    const detectedLanguages = new Set();
+    const scanWarnings = [];
+    const evidence = [];
+    for (const absolutePath of sortUnique(metadataFiles)) {
+        const relativePath = toRelativePosixPath(workspaceRoot, absolutePath);
+        const basename = path.basename(relativePath);
+        const data = {
+            title: `Repository metadata: ${basename}`,
+            factKind: "meta",
+            confidence: basename.startsWith("tsconfig") ? 0.9 : 0.86,
+            evidence: [`repo_metadata:${relativePath}`],
+        };
+        if (basename.startsWith("tsconfig")) {
+            detectedLanguages.add("typescript");
+        }
+        if (basename === "Cargo.toml") {
+            detectedLanguages.add("rust");
+        }
+        if (basename === "go.mod") {
+            detectedLanguages.add("go");
+        }
+        if (basename === "pyproject.toml") {
+            detectedLanguages.add("python");
+        }
+        if (basename === "package.json") {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(absolutePath, "utf8"));
+                for (const language of detectLanguagesFromPackageJson(parsed)) {
+                    detectedLanguages.add(language);
+                }
+                if (typeof parsed.packageManager === "string") {
+                    data.packageManager = parsed.packageManager;
+                }
+            }
+            catch (error) {
+                scanWarnings.push(`repo_metadata:failed_to_parse:${relativePath}`);
+            }
+        }
+        evidence.push(createFileEvidence("repo_metadata", "repo_metadata", workspaceRoot, absolutePath, data));
+    }
+    return {
+        provider: "repo_metadata",
+        evidence,
+        detectedLanguages: Array.from(detectedLanguages),
+        scanWarnings,
+    };
+}
+function runRepoLayoutProvider(workspaceRoot, vendoredRoots) {
+    const layoutRoots = ["src", "app", "apps", "packages", "tests", "test", "docs", "scripts"];
+    const evidence = [];
+    for (const relativePath of layoutRoots) {
+        const absolutePath = path.join(workspaceRoot, relativePath);
+        if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isDirectory()) {
+            continue;
+        }
+        evidence.push({
+            provider: "repo_layout",
+            kind: "repo_layout",
+            label: relativePath,
+            relativePath,
+            absolutePath,
+            data: {
+                title: `Repository layout: ${relativePath} directory`,
+                factKind: "observation",
+                confidence: 0.84,
+                evidence: [`repo_layout:${relativePath}`],
+            },
+        });
+    }
+    const codeFiles = fg.sync([
+        "src/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "app/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "apps/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "packages/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "tests/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "test/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+    ], {
+        cwd: workspaceRoot,
+        absolute: true,
+        onlyFiles: true,
+        unique: true,
+        suppressErrors: true,
+        ignore: buildIgnoredGlobs(vendoredRoots),
+    });
+    return {
+        provider: "repo_layout",
+        evidence,
+        detectedLanguages: detectLanguagesFromPaths(codeFiles),
+    };
+}
+function detectTestFrameworksFromContent(content) {
+    const frameworks = new Set();
+    if (/\bbun:test\b/.test(content))
+        frameworks.add("bun:test");
+    if (/\bvitest\b/.test(content))
+        frameworks.add("vitest");
+    if (/\bnode:test\b/.test(content))
+        frameworks.add("node:test");
+    if (/\bmocha\b/.test(content))
+        frameworks.add("mocha");
+    if (/\bjest\b|@jest\/globals/.test(content))
+        frameworks.add("jest");
+    return Array.from(frameworks);
+}
+function runTestTopologyProvider(workspaceRoot, vendoredRoots) {
+    const testFiles = fg.sync([
+        "**/*.test.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+        "**/*.spec.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+        "**/__tests__/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+    ], {
+        cwd: workspaceRoot,
+        absolute: true,
+        onlyFiles: true,
+        unique: true,
+        suppressErrors: true,
+        ignore: buildIgnoredGlobs(vendoredRoots),
+    });
+    const detectedFrameworks = new Set();
+    const detectedLanguages = new Set();
+    const scanWarnings = [];
+    const evidence = [];
+    for (const absolutePath of sortUnique(testFiles)) {
+        const relativePath = toRelativePosixPath(workspaceRoot, absolutePath);
+        const frameworks = (() => {
+            try {
+                return detectTestFrameworksFromContent(fs.readFileSync(absolutePath, "utf8"));
+            }
+            catch (error) {
+                scanWarnings.push(`test_topology:failed_to_read:${relativePath}`);
+                return [];
+            }
+        })();
+        for (const framework of frameworks) {
+            detectedFrameworks.add(framework);
+        }
+        for (const language of detectLanguagesFromPaths([absolutePath])) {
+            detectedLanguages.add(language);
+        }
+        evidence.push(createFileEvidence("test_topology", "test_topology", workspaceRoot, absolutePath, {
+            title: frameworks.length > 0
+                ? `Test topology: ${frameworks.join(", ")} in ${relativePath}`
+                : `Test topology: ${relativePath}`,
+            factKind: "observation",
+            confidence: frameworks.length > 0 ? 0.92 : 0.85,
+            evidence: [
+                `test_topology:${relativePath}`,
+                ...frameworks.map((framework) => `framework:${framework}`),
+            ],
+            frameworks,
+        }));
+    }
+    return {
+        provider: "test_topology",
+        evidence,
+        detectedLanguages: Array.from(detectedLanguages),
+        detectedTestFrameworks: Array.from(detectedFrameworks),
+        scanWarnings,
+    };
+}
+function runSourceSymbolsProvider(workspaceRoot, vendoredRoots) {
+    const analyzeSourceText = cliSymbolCoordinator.analyzeSourceText;
+    const sourceFiles = fg.sync([
+        "src/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "app/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "apps/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+        "packages/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+    ], {
+        cwd: workspaceRoot,
+        absolute: true,
+        onlyFiles: true,
+        unique: true,
+        suppressErrors: true,
+        ignore: buildIgnoredGlobs(vendoredRoots),
+    });
+    const evidence = [];
+    const detectedLanguages = new Set();
+    const scanWarnings = [];
+    for (const absolutePath of sortUnique(sourceFiles)) {
+        const relativePath = toRelativePosixPath(workspaceRoot, absolutePath);
+        const language = SOURCE_LANGUAGE_EXTENSIONS[path.extname(absolutePath).toLowerCase()] ?? "unknown";
+        detectedLanguages.add(language);
+        try {
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const analysis = analyzeSourceText
+                ? analyzeSourceText(relativePath, content)
+                : {
+                    sourceFile: relativePath,
+                    language,
+                    providerId: null,
+                    module: {
+                        title: path.basename(relativePath, path.extname(relativePath)) || relativePath,
+                        analysisMode: "fallback",
+                        fallbackReason: "provider_unavailable",
+                    },
+                    symbols: [],
+                };
+            if (analysis.symbols.length > 0) {
+                evidence.push({
+                    provider: "source_symbols",
+                    kind: "source_symbols",
+                    label: relativePath,
+                    relativePath,
+                    absolutePath,
+                    data: {
+                        title: `Source symbols: ${analysis.module.title}`,
+                        factKind: "observation",
+                        confidence: 0.9,
+                        evidence: [
+                            `source_symbols:${relativePath}`,
+                            `language:${analysis.language}`,
+                            `provider:${analysis.providerId ?? "fallback"}`,
+                            ...analysis.symbols
+                                .slice(0, 5)
+                                .map((symbol) => `symbol:${symbol.kind}:${symbol.name}`),
+                        ],
+                        analysisMode: analysis.module.analysisMode,
+                        providerId: analysis.providerId,
+                        symbolCount: analysis.symbols.length,
+                    },
+                });
+                continue;
+            }
+            evidence.push({
+                provider: "source_symbols",
+                kind: "source_symbols",
+                label: relativePath,
+                relativePath,
+                absolutePath,
+                data: {
+                    title: `Source module: ${analysis.module.title}`,
+                    factKind: "observation",
+                    confidence: 0.82,
+                    evidence: [
+                        `source_symbols:${relativePath}`,
+                        `language:${analysis.language}`,
+                        `analysis_mode:${analysis.module.analysisMode}`,
+                        ...(analysis.module.fallbackReason
+                            ? [`fallback:${analysis.module.fallbackReason}`]
+                            : []),
+                    ],
+                    analysisMode: analysis.module.analysisMode,
+                    fallbackReason: analysis.module.fallbackReason,
+                    providerId: analysis.providerId,
+                    symbolCount: 0,
+                },
+            });
+        }
+        catch {
+            scanWarnings.push(`source_symbols:failed_to_analyze:${relativePath}`);
+        }
+    }
+    return {
+        provider: "source_symbols",
+        evidence,
+        detectedLanguages: Array.from(detectedLanguages),
+        scanWarnings,
+    };
+}
+function buildDiscoverySummary(activation, vendored, providerResults) {
+    const providerCounts = createEmptyProviderCounts();
+    const detectedLanguages = new Set();
+    const detectedTestFrameworks = new Set();
+    const scanWarnings = [];
+    let truncated = false;
+    for (const result of providerResults) {
+        providerCounts[result.provider] = result.evidence.length;
+        for (const language of result.detectedLanguages ?? []) {
+            detectedLanguages.add(language);
+        }
+        for (const framework of result.detectedTestFrameworks ?? []) {
+            detectedTestFrameworks.add(framework);
+        }
+        scanWarnings.push(...(result.scanWarnings ?? []));
+        truncated ||= Boolean(result.truncated);
+    }
+    return {
+        ...buildSourceSummary(activation, vendored),
+        providersRun: providerResults.map((result) => result.provider),
+        providerCounts,
+        detectedLanguages: Array.from(detectedLanguages).sort(),
+        detectedTestFrameworks: Array.from(detectedTestFrameworks).sort(),
+        excludedRoots: Array.from(IGNORED_DIRECTORY_NAMES).sort(),
+        truncated,
+        scanWarnings: sortUnique(scanWarnings),
+    };
+}
+// implements REQ-001
+export function discoverProviderEvidence(workspaceRoot, activation) {
+    const vendored = findVendoredTrees(workspaceRoot);
+    if (!activation.allowCandidateGeneration) {
+        return {
+            evidence: [],
+            providerResults: [],
+            summary: {
+                ...buildSourceSummary(activation, vendored),
+                providersRun: [],
+                providerCounts: createEmptyProviderCounts(),
+                detectedLanguages: [],
+                detectedTestFrameworks: [],
+                excludedRoots: Array.from(IGNORED_DIRECTORY_NAMES).sort(),
+                truncated: false,
+                scanWarnings: [],
+            },
+        };
+    }
+    const typedKibiDocs = runTypedKibiDocsProvider(workspaceRoot);
+    const typedPaths = new Set(typedKibiDocs.evidence
+        .map((item) => item.relativePath)
+        .filter((item) => Boolean(item)));
+    const providerResults = [
+        typedKibiDocs,
+        runGenericRepoDocsProvider(workspaceRoot, vendored, typedPaths),
+        runRepoMetadataProvider(workspaceRoot),
+        runRepoLayoutProvider(workspaceRoot, vendored),
+        runTestTopologyProvider(workspaceRoot, vendored),
+        runSourceSymbolsProvider(workspaceRoot, vendored),
+    ];
+    const evidence = providerResults.flatMap((result) => result.evidence);
+    evidence.sort((left, right) => {
+        const providerCompare = AUTOPILOT_PROVIDER_ORDER.indexOf(left.provider) -
+            AUTOPILOT_PROVIDER_ORDER.indexOf(right.provider);
+        if (providerCompare !== 0)
+            return providerCompare;
+        const leftKey = left.relativePath ?? left.label;
+        const rightKey = right.relativePath ?? right.label;
+        return leftKey.localeCompare(rightKey);
+    });
+    return {
+        evidence,
+        providerResults,
+        summary: buildDiscoverySummary(activation, vendored, providerResults),
+    };
+}
+function toActivationPolicy(activationState) {
+    switch (activationState) {
+        case "root_partial":
+            return {
+                activationState,
+                activationMode: "repair_bootstrap",
+                applyBlocked: true,
+                allowCandidateGeneration: true,
+                reason: "Workspace root is only partially configured; run a repair bootstrap scan and keep apply blocked until the root is repaired.",
+            };
+        case "root_active_thin":
+            return {
+                activationState,
+                activationMode: "attached_thin_handoff",
+                applyBlocked: true,
+                allowCandidateGeneration: false,
+                reason: "Workspace already has an attached but thin KB; bootstrap synthesis is replaced by an explicit thin handoff.",
+                handoffMessage: "Attached thin KB detected. Review the sparse KB coverage and continue with a handoff instead of a bootstrap apply plan.",
+            };
+        case "root_active_seeded":
+            return {
+                activationState,
+                activationMode: "attached_seeded_handoff",
+                applyBlocked: true,
+                allowCandidateGeneration: false,
+                reason: "Workspace already has an attached seeded KB; bootstrap synthesis is replaced by an explicit seeded handoff.",
+                handoffMessage: "Attached seeded KB detected. Use the existing KB context instead of generating bootstrap candidates.",
+            };
+        case "vendored_only":
+            return {
+                activationState,
+                activationMode: "vendored_blocked",
+                applyBlocked: true,
+                allowCandidateGeneration: false,
+                reason: "Workspace appears to contain vendored Kibi sources only; bootstrap generation is blocked in this posture.",
+                handoffMessage: "Vendored Kibi posture detected. Move to the real project root before attempting bootstrap.",
+            };
+        case "root_uninitialized":
+            return {
+                activationState,
+                activationMode: "cold_start_bootstrap",
+                applyBlocked: false,
+                allowCandidateGeneration: true,
+                reason: "Workspace has no attached root KB yet; run a cold-start bootstrap scan across repository evidence.",
+            };
+    }
+}
+// implements REQ-mcp-init-kibi-autopilot-v1
+export async function resolveActivationPolicy(workspaceRoot, prolog) {
+    return toActivationPolicy(await classifyActivationState(workspaceRoot, prolog));
+}
 function rootTargetsAllResolve(cwd) {
     const config = readRootConfig(cwd) || {};
     const paths = config.paths ?? {};
@@ -116,7 +773,9 @@ function rootTargetsAllResolve(cwd) {
 export async function classifyActivationState(workspaceRoot, prolog) {
     const hasRootConfig = rootKbConfigExists(workspaceRoot);
     const vendored = findVendoredTrees(workspaceRoot);
-    if (!hasRootConfig && vendored.length > 0) {
+    if (!hasRootConfig &&
+        vendored.length > 0 &&
+        !hasWorkspaceProjectSignals(workspaceRoot, vendored)) {
         return "vendored_only";
     }
     if (!hasRootConfig) {
@@ -166,11 +825,11 @@ function collectMarkdownFiles(dir, workspaceRoot, vendoredRoots) {
     const stat = fs.statSync(dir);
     if (!stat.isDirectory())
         return results;
-    const entries = fs.readdirSync(dir);
+    const entries = fs.readdirSync(dir).sort();
     for (const entry of entries) {
         const full = path.join(dir, entry);
         // Skip ignores
-        if (entry === ".git" || entry === "node_modules" || entry === ".kb")
+        if (IGNORED_DIRECTORY_NAMES.has(entry.toLowerCase()))
             continue;
         // Skip vendored roots
         const rel = path.relative(workspaceRoot, full).split(path.sep).join("/");
@@ -189,55 +848,22 @@ function collectMarkdownFiles(dir, workspaceRoot, vendoredRoots) {
 }
 /** Discover eligible source inputs for autopilot. */
 // implements REQ-mcp-init-kibi-autopilot-v1
-export function discoverSources(workspaceRoot, activationState) {
-    const vendored = findVendoredTrees(workspaceRoot);
-    if (activationState === "vendored_only") {
-        return { candidates: [], summary: { activationState, vendored } };
-    }
-    const config = readRootConfig(workspaceRoot) || {};
-    const paths = config.paths ??
-        DEFAULT_SYNC_PATHS;
+export function discoverSources(workspaceRoot, activation) {
+    const discovery = discoverProviderEvidence(workspaceRoot, activation);
     const candidates = new Set();
-    // First: configured KB paths (include documentation/* if configured)
-    for (const key of Object.keys(DEFAULT_SYNC_PATHS)) {
-        const raw = paths[key];
-        if (!raw)
-            continue;
-        const normalized = raw.replace(/\s+$/, "");
-        if (normalized.endsWith(".yaml") || normalized.endsWith(".yml")) {
-            const abs = path.resolve(workspaceRoot, normalized);
-            if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
-                candidates.add(path.relative(workspaceRoot, abs).split(path.sep).join("/"));
+    for (const item of discovery.evidence) {
+        if (item.kind === "typed_markdown" ||
+            item.kind === "symbol_manifest" ||
+            item.kind === "generic_markdown" ||
+            item.kind === "source_symbols") {
+            const relativePath = item.relativePath;
+            if (relativePath) {
+                candidates.add(relativePath);
             }
-            continue;
-        }
-        const pat = normalizePattern(normalized) ?? normalized;
-        const root = stripToRoot(pat);
-        const absRoot = path.resolve(workspaceRoot, root);
-        if (fs.existsSync(absRoot) && fs.statSync(absRoot).isDirectory()) {
-            for (const f of collectMarkdownFiles(absRoot, workspaceRoot, vendored)) {
-                candidates.add(f);
-            }
-        }
-    }
-    // Generic markdown candidates (top-level), but exclude documentation/** which
-    // is treated above via configured paths.
-    for (const file of ["README.md", "ARCHITECTURE.md"]) {
-        const abs = path.resolve(workspaceRoot, file);
-        if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
-            const rel = path.relative(workspaceRoot, abs).split(path.sep).join("/");
-            if (!rel.startsWith("documentation/"))
-                candidates.add(rel);
-        }
-    }
-    const docsRoot = path.resolve(workspaceRoot, "docs");
-    if (fs.existsSync(docsRoot) && fs.statSync(docsRoot).isDirectory()) {
-        for (const f of collectMarkdownFiles(docsRoot, workspaceRoot, vendored)) {
-            candidates.add(f);
         }
     }
     return {
         candidates: Array.from(candidates).sort(),
-        summary: { activationState, reason: "discovered sources", vendored },
+        summary: discovery.summary,
     };
 }