kibi-mcp 0.7.1 → 0.9.0

package/dist/server/docs.js

@@ -35,70 +35,83 @@ function renderToolsDoc() {
             : "none";
     }
     lines.push("");
-    lines.push("Modeling note: Prefer query-first discovery; create `fact` entities before `req` entities and express semantics via `constrains` + `requires_property`.");
+    lines.push("Modeling note: Kibi has eight core entity types grouped into common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).");
+    lines.push("Only strict domain facts (`fact_kind: subject` + `property_value`) participate in contradiction inference; use `flag` for runtime/config gates and `fact_kind: observation` or `meta` for bug/workaround notes.");
     return lines.join("\n");
 }
 export const PROMPTS = [
     // implements REQ-002, REQ-013, REQ-mcp-search-discovery
     {
         name: "init-kibi",
-        description: "Bootstrap Kibi on an existing repository with zero entities.",
+        description: "Activation workflow to populate a new or empty Kibi KB from an existing repository.",
         text: [
-            "# Kibi Initialization Workflow",
+            "# Kibi Activation Workflow",
             "",
-            "Use this workflow to retroactively bootstrap Kibi on an existing repository with zero entities.",
+            "Use this workflow to populate a Kibi knowledge base when it is new or empty.",
             "",
-            "## Phase 1: Discovery",
-            "1. Scan project structure to identify:",
-            "   - Requirements (docs/requirements/, README, specs)",
-            "   - Tests (unit, integration, e2e)",
-            "   - Architecture decisions (docs/adr/, ARCHITECTURE.md)",
-            "   - Feature flags (environment files, config)",
-            "   - Events (domain events, pub/sub topics)",
-            "   - Core symbols (key functions, classes, modules)",
+            "## Step 1: Generate Candidates (read-only)",
             "",
-            "## Phase 2: Fact Extraction",
-            "1. Identify atomic domain facts (invariants, constraints, properties)",
-            "2. Create reusable fact entities with `kb_upsert` using type 'fact'",
-            "3. Use consistent IDs: FACT-XXX with descriptive titles",
+            "Call `kb_autopilot_generate` to scan the repository and produce candidate entities.",
             "",
-            "## Phase 3: Requirement Encoding",
-            "1. Extract requirements from documentation",
-            "2. For each requirement, determine which facts it constrains or requires",
-            "3. Create req entities with `kb_upsert` using type 'req'",
-            "4. Link reqs to facts using `constrains` and `requires_property` relationships",
-            "5. Reuse fact IDs across related requirements for contradiction detection",
+            "This tool is **read-only** — it never writes to the KB. It returns:",
+            "- `activationState`: the current KB state (e.g. `root_uninitialized`, `root_partial`)",
+            "- `candidates[]`: proposed entities with confidence scores and evidence",
+            "- `suppressedCandidates[]`: candidates suppressed due to duplicates, existing entities, or shadowed by typed sources",
+            "- `discoverySummary` / `payoffSummary`: context for agent review",
             "",
-            "## Phase 4: Test Linking",
-            "1. Map existing tests to requirements they verify",
-            "2. Create test entities with `kb_upsert` using type 'test'",
-            "3. Link tests to requirements using `verified_by` relationship",
+            "## Step 2: Review Candidates",
             "",
-            "## Phase 5: Architecture Documentation",
-            "1. Extract ADRs from docs/adr/ or decision records",
-            "2. Create adr entities with `kb_upsert` using type 'adr'",
-            "3. Link ADRs to symbols they constrain using `constrained_by`",
+            "Inspect `activationState`. If `applyBlocked` is true, stop — the KB cannot accept writes.",
             "",
-            "## Phase 6: Event Catalog",
-            "1. Identify domain/system events from code",
-            "2. Create event entities with `kb_upsert` using type 'event'",
-            "3. Link symbols that publish/consume events using `publishes`/`consumes`",
+            "For each candidate, evaluate:",
+            "- **confidence** (0–1): prefer high-confidence entities first",
+            "- **evidence**: verify the source reference is real before applying",
             "",
-            "## Phase 7: Symbol Mapping",
-            "1. Map key code symbols to requirements",
-            "2. Create symbol entities with `kb_upsert` using type 'symbol'",
-            "3. Link symbols to requirements using `implements`",
+            "Discard or edit candidates that look speculative. The agent decides what to apply — the generator never writes.", "",
+            "## Step 3: Apply Approved Candidates", "",
+            "Apply approved candidates by executing each candidate.applyPlan sequentially:",
+            "1. For each approved candidate, run its `candidate.applyPlan` steps in ascending phase order and keep the candidate sequence deterministic",
+            "2. Execute each step with `kb_upsert` using the step's provided args, and confirm success before moving to the next step",
+            "3. After each batch, call `kb_check` with targeted rules (`required-fields`, `no-dangling-refs`) to catch issues early",
             "",
-            "## Phase 8: Validation",
-            "1. Run `kb_check` with all rules to verify integrity",
-            "2. Fix any dangling references or constraint violations",
-            "3. Re-run validation until clean",
+            "## Step 4: Payoff Verification",
+            "",
+            "After all approved candidates are applied, verify the result:",
+            "- `kb_check` with all rules — must return zero violations",
+            "- `kb_find_gaps` with `{ type: 'req', missingRelationships: ['specified_by', 'verified_by'] }` — identify under-linked requirements",
+            "- `kb_coverage` with `{ by: 'req' }` — confirm traceability coverage", "",
+            "## Doc Hygiene",
             "",
-            "## Best Practices",
-            "- Start with high-value entities first (critical requirements, security constraints)",
-            "- Use incremental batches to avoid overwhelming the KB",
             "- Always call `kb_query` before creating to avoid duplicate entities",
-            "- Run `kb_check` after each batch of changes",
+            "- Run `kb_check` after each batch, not just at the end",
+            "- All writes go through `kb_upsert` — do not invoke CLI commands directly",
+            "- `kb_autopilot_generate` is read-only; only `kb_upsert` mutates the KB",
+        ].join("\n"),
+    },
+    {
+        name: "brief-kibi",
+        description: "Start-task workflow for generating a citation-backed Kibi briefing before risky work.",
+        text: [
+            "# Kibi Briefing Workflow",
+            "",
+            "Use this workflow at the start of a task when you need a deterministic, citation-backed Kibi briefing.",
+            "",
+            "## Step 1: Generate the briefing",
+            "",
+            "Call `kb_briefing_generate` with any relevant `taskText`, `sourceFiles`, and `seedIds`.",
+            "",
+            "This tool is read-only. It returns `briefingState`, `activationState`, `activationReason`, `freshness`, `confidence`, `tldr`, `promptBlock`, `entities`, `constraints`, `regressionRisks`, `missingEvidence`, and `citations`.",
+            "",
+            "## Step 2: Inspect readiness",
+            "",
+            "Inspect `briefingState` before acting.",
+            "- If `briefingState` is `ready`, continue using only cited output from the briefing.",
+            "- If `briefingState` is `no_briefing`, stop and proceed without inventing briefing claims.",
+            "",
+            "## Step 3: Use the cited output",
+            "",
+            "Use `constraints`, `regressionRisks`, `missingEvidence`, and `promptBlock` only when their claims are backed by the returned `citations` and cited `entities`.",
+            "Do not add uncited assertions, and do not treat omitted topics as verified.",
         ].join("\n"),
     },
     {
@@ -121,14 +134,14 @@ export const PROMPTS = [
             "- `kb_check`: Validate KB integrity against configurable rules",
             "",
             "Core modeling principles:",
+            "- Kibi has eight entity types: common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).",
             "- Encode requirements as linked facts: `req --constrains--> fact` plus `req --requires_property--> fact`.",
-            "- Reuse canonical fact IDs across requirements; shared constrained facts make contradictions detectable.",
+            "- Only strict domain facts (`fact_kind: subject` + `property_value`) participate in contradiction inference; observation and meta facts are non-blocking notes.",
             "- Use `kb_search` first for discovery, then `kb_query` for exact follow-up before any mutation.",
             "- Use `kb_upsert` and `kb_delete` only for intentional, traceable KB changes.",
             "- Run `kb_check` after meaningful mutations to catch integrity issues early.",
             "- Prefer explicit IDs and enum values to avoid invalid parameters.",
-            "- Assume every write can affect downstream traceability queries.",
-            "- Model requirements by first creating/reusing fact entities, then express req semantics with `constrains` + `requires_property` relationships (create-before-link).",
+            "- Model requirements by first creating/reusing fact entities (create-before-link).",
             "- flag gates runtime/config behavior; use `fact` with `fact_kind: observation` or `meta` for bug and workaround notes.",
         ].join("\n"),
     },
@@ -211,7 +224,8 @@ function registerDocResources() {
         "4. Reuse the same constrained fact ID across related requirements; vary property facts only when semantics differ",
         '5. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }` for targeted validation',
         "",
-        "Note: Create or reuse `fact` entities first, then create `req` entities and link with `constrains` and `requires_property` (create-before-link). Use `flag` for runtime/config gates; use `fact` with `fact_kind: observation` or `meta` for bug and workaround notes.",
+        "Note: Kibi has eight core entity types. Create or reuse `fact` entities first, then create `req` entities and link with `constrains` and `requires_property` (create-before-link).",
+        "Only strict domain facts are contradiction-safe. Use `flag` for runtime/config gates; use `fact` with `fact_kind: observation` or `meta` for bug/workaround notes.",
         "",
         "## Find missing coverage",
         '1. `kb_find_gaps` with `{ "type": "req", "missingRelationships": ["specified_by", "verified_by"] }` to find under-linked requirements',

package/dist/server/tools.js

@@ -11,6 +11,8 @@ import { handleKbQuery } from "../tools/query.js";
 import { handleKbSearch } from "../tools/search.js";
 import { handleKbStatus } from "../tools/status.js";
 import { handleKbUpsert } from "../tools/upsert.js";
+import { handleKbAutopilotGenerate, } from "../tools/autopilot-generate.js";
+import { handleKbBriefingGenerate, } from "../tools/briefing-generate.js";
 const defaultToolsServerDeps = {
     getSessionModule: () => import("./session.js"),
 };
@@ -57,6 +59,8 @@ const DEFAULT_TOOLS_RUNTIME = {
     handleKbSearch,
     handleKbStatus,
     handleKbUpsert,
+    handleKbAutopilotGenerate,
+    handleKbBriefingGenerate,
 };
 // implements REQ-008
 function debugLog(...args) {
@@ -317,4 +321,12 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
         const prolog = await runtime.ensureProlog();
         return runtime.handleKbCheck(prolog, args);
     }, runtime);
+    addTool(server, "kb_autopilot_generate", toolDef("kb_autopilot_generate").description, toolDef("kb_autopilot_generate").inputSchema, async (args) => {
+        const prolog = await runtime.ensureProlog();
+        return runtime.handleKbAutopilotGenerate(prolog, args);
+    }, runtime);
+    addTool(server, "kb_briefing_generate", toolDef("kb_briefing_generate").description, toolDef("kb_briefing_generate").inputSchema, async (args) => {
+        const prolog = await runtime.ensureProlog();
+        return runtime.handleKbBriefingGenerate(prolog, args);
+    }, runtime);
 }

package/dist/tools/autopilot-candidates.js

@@ -0,0 +1,229 @@
+// Kibi — autopilot candidate builders
+// Implements candidate assembly from public CLI extractors
+import { extractFromManifest } from "kibi-cli/extractors/manifest";
+import { extractFromMarkdown } from "kibi-cli/extractors/markdown";
+import path from "node:path";
+import fs from "node:fs";
+function resolveCandidatePaths(filePath, workspaceRoot) {
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(workspaceRoot, filePath);
+    const relativePath = (path.relative(workspaceRoot, absolutePath) || filePath)
+        .split(path.sep)
+        .join("/");
+    return { absolutePath, relativePath };
+}
+function isIgnoredGenericMarkdownPath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+    return /(^|\/)(documentation|\.kb|\.git|node_modules|vendor|vendors|third_party|third-party|dist|coverage)(\/|$)/.test(normalized);
+}
+function buildUpsertFromExtraction(er, typeOverride) {
+    const ent = er.entity;
+    const type = typeOverride ?? String(ent.type ?? "");
+    const id = String(ent.id ?? "");
+    // Copy properties except `type` to avoid delete
+    const properties = {};
+    for (const [k, v] of Object.entries(ent)) {
+        if (k === "type")
+            continue;
+        properties[k] = v;
+    }
+    return {
+        type,
+        id,
+        properties,
+        relationships: er.relationships ?? [],
+    };
+}
+// implements REQ-mcp-init-kibi-autopilot-v1
+export function buildTypedMarkdownCandidates(discoveryResult, existingEntities) {
+    const candidates = [];
+    const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    for (const filePath of discoveryResult.markdownFiles || []) {
+        try {
+            const extraction = extractFromMarkdown(filePath);
+            const { entity, relationships } = extraction;
+            if (existingEntities.ids.has(entity.id))
+                continue;
+            const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
+            const candidateId = `md:${relativePath}:${entity.id}`;
+            const upsert = buildUpsertFromExtraction({ entity, relationships });
+            candidates.push({
+                candidateId,
+                entityType: entity.type,
+                title: entity.title,
+                sourceKind: "typed_markdown",
+                sourcePath: absolutePath,
+                confidence: 1.0,
+                confidenceBand: "high",
+                evidence: [
+                    `extracted_from_markdown:${relativePath}`,
+                    `entity_id:${entity.id}`,
+                ],
+                relationships: relationships || [],
+                applyPlan: [upsert],
+            });
+        }
+        catch (error) {
+            // skip files that fail extraction
+        }
+    }
+    return candidates;
+}
+// implements REQ-mcp-init-kibi-autopilot-v1
+export function buildSymbolManifestCandidates(discoveryResult, existingEntities) {
+    const candidates = [];
+    const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    for (const filePath of discoveryResult.manifestFiles || []) {
+        try {
+            const results = extractFromManifest(filePath);
+            for (const res of results) {
+                const entity = res.entity;
+                const relationships = res.relationships || [];
+                if (existingEntities.ids.has(entity.id))
+                    continue;
+                const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
+                const candidateId = `mf:${relativePath}:${entity.id}`;
+                const upsert = buildUpsertFromExtraction({ entity, relationships });
+                candidates.push({
+                    candidateId,
+                    entityType: entity.type,
+                    title: entity.title,
+                    sourceKind: "symbol_manifest",
+                    sourcePath: absolutePath,
+                    confidence: 0.98,
+                    confidenceBand: "high",
+                    evidence: [
+                        `extracted_from_manifest:${relativePath}`,
+                        `entity_id:${entity.id}`,
+                    ],
+                    relationships,
+                    applyPlan: [upsert],
+                });
+            }
+        }
+        catch (error) {
+            // skip manifest parse errors
+        }
+    }
+    return candidates;
+}
+/**
+ * Conservative generic markdown candidate builder.
+ * Scans a small, safe set of top-level markdown files and emits only
+ * ADR/REQ/FACT candidates when clear heading heuristics match.
+ *
+ * discoveryResult.markdownFiles is expected to be a list of file paths
+ * (absolute or relative). Files under documentation/**, .kb/**, .git/**,
+ * node_modules/**, vendor/**, third_party/** are ignored to avoid vendored
+ * trees and double-counting typed Kibi docs.
+ */
+// implements REQ-mcp-init-kibi-autopilot-v1
+export function buildGenericMarkdownCandidates(discoveryResult, existingEntities, minConfidence = 0.8) {
+    const candidates = [];
+    const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    const files = discoveryResult.markdownFiles ?? [];
+    for (const rawPath of files) {
+        try {
+            const filePath = String(rawPath);
+            const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
+            if (isIgnoredGenericMarkdownPath(relativePath))
+                continue;
+            const base = path.basename(relativePath).toLowerCase();
+            const inDocsDir = /(^|\/)docs\//.test(relativePath);
+            // Only scan README.md, ARCHITECTURE.md or files under docs/**
+            if (!(base === "readme.md" || base === "architecture.md" || inDocsDir)) {
+                continue;
+            }
+            if (!fs.existsSync(absolutePath))
+                continue;
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const lines = content.split(/\r?\n/);
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line === undefined)
+                    continue;
+                const headingMatch = line.match(/^\s*#+\s*(.+)$/);
+                if (!headingMatch)
+                    continue;
+                const headingRaw = headingMatch[1];
+                if (!headingRaw)
+                    continue;
+                const heading = headingRaw.trim();
+                const headingLower = heading.toLowerCase();
+                let type = null;
+                let confidence = 0;
+                // ADR heuristic: headings that mention ADR or Architectural Decision
+                if (/\badr\b/i.test(heading) || /architectur.*decision/i.test(heading)) {
+                    type = "adr";
+                    confidence = 0.9;
+                }
+                // Requirements heuristic: explicit Requirements heading
+                if (!type && /\brequirements?\b/i.test(heading)) {
+                    type = "req";
+                    confidence = 0.85;
+                }
+                // Fact/Observation heuristic
+                if (!type && /\b(observations?|facts?|notes?)\b/i.test(heading)) {
+                    type = "fact";
+                    confidence = 0.8;
+                }
+                if (!type)
+                    continue;
+                // Suppress below-threshold candidates early
+                if (confidence < minConfidence)
+                    continue;
+                // Build a safe ID for the candidate. Use a repo-relative slug so it's
+                // deterministic across runs and comparable to typed candidates.
+                const slug = heading
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, "-")
+                    .replace(/(^-|-$)/g, "")
+                    .slice(0, 60);
+                const idPrefix = type === "adr" ? "ADR" : type === "req" ? "REQ" : "FACT";
+                const genId = `${idPrefix}-GEN-${slug || path.basename(relativePath).replace(/\.[^.]+$/, "")}`.toUpperCase();
+                if (existingEntities.ids.has(genId))
+                    continue;
+                // Entity record for applyPlan; keep properties minimal and safe.
+                const entity = {
+                    type,
+                    id: genId,
+                    title: heading,
+                    status: type === "fact" ? "active" : type === "adr" ? "proposed" : "open",
+                    source: `autopilot:generic:${relativePath}`,
+                    text_ref: `${relativePath}#L${i + 1}`,
+                };
+                if (type === "fact") {
+                    // Generic facts are observations by policy
+                    entity.fact_kind = "observation";
+                }
+                const upsert = buildUpsertFromExtraction({
+                    entity: entity,
+                    relationships: [],
+                }, type);
+                const candidateId = `gen:${relativePath}:${type}:${slug}`;
+                const confidenceBand = confidence >= 0.95 ? "high" : "medium";
+                candidates.push({
+                    candidateId,
+                    entityType: type,
+                    title: heading,
+                    sourceKind: "generic_markdown",
+                    sourcePath: absolutePath,
+                    confidence,
+                    confidenceBand,
+                    evidence: [`generic_heading:${relativePath}#L${i + 1}`],
+                    relationships: [],
+                    applyPlan: [upsert],
+                });
+            }
+        }
+        catch (error) {
+            // skip unreadable files silently
+        }
+    }
+    return candidates;
+}
+export default {
+    buildTypedMarkdownCandidates,
+    buildSymbolManifestCandidates,
+};

package/dist/tools/autopilot-discovery.js

@@ -0,0 +1,243 @@
+/*
+ * Autopilot discovery helpers
+ *
+ * Provides lightweight workspace activation classification and source discovery
+ * used by the `kb_autopilot_generate` workflow.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { runJsonModuleQuery } from "./core-module.js";
+// 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 = {
+    requirements: "documentation/requirements/**/*.md",
+    scenarios: "documentation/scenarios/**/*.md",
+    tests: "documentation/tests/**/*.md",
+    adr: "documentation/adr/**/*.md",
+    flags: "documentation/flags/**/*.md",
+    events: "documentation/events/**/*.md",
+    facts: "documentation/facts/**/*.md",
+    symbols: "documentation/symbols.yaml",
+};
+function findVendoredTrees(cwd) {
+    const results = [];
+    const vendoredMarkers = [
+        ["kibi", "opencode.json"],
+        ["kibi", "package.json"],
+        ["kibi", "packages", "mcp"],
+        ["kibi", "documentation"],
+    ];
+    for (const marker of vendoredMarkers) {
+        const markerPath = path.join(cwd, ...marker);
+        if (fs.existsSync(markerPath)) {
+            results.push(marker.join("/"));
+        }
+    }
+    const nodeModules = path.join(cwd, "node_modules");
+    if (fs.existsSync(nodeModules)) {
+        try {
+            for (const entry of fs.readdirSync(nodeModules)) {
+                if (entry === "kibi" || entry.startsWith("kibi-")) {
+                    results.push(`node_modules/${entry}`);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return Array.from(new Set(results));
+}
+function rootKbConfigExists(cwd) {
+    return fs.existsSync(path.join(cwd, ".kb", "config.json"));
+}
+function readRootConfig(cwd) {
+    try {
+        const raw = fs.readFileSync(path.join(cwd, ".kb", "config.json"), "utf8");
+        return JSON.parse(raw) || null;
+    }
+    catch {
+        return null;
+    }
+}
+function stripToRoot(p) {
+    const segments = p.split("/");
+    const rootSegments = [];
+    for (const seg of segments) {
+        if (seg.includes("*") || seg.includes("?") || seg.includes("["))
+            break;
+        rootSegments.push(seg);
+    }
+    const result = rootSegments.join("/");
+    return result || ".";
+}
+function normalizePattern(p) {
+    if (!p)
+        return null;
+    if (p.includes("*"))
+        return p;
+    if (p.endsWith(".yaml") || p.endsWith(".yml") || path.extname(p))
+        return p;
+    return `${p.replace(/\/+$/, "")}/**/*.md`;
+}
+function rootTargetsAllResolve(cwd) {
+    const config = readRootConfig(cwd) || {};
+    const paths = config.paths ?? {};
+    const keys = [
+        "requirements",
+        "scenarios",
+        "tests",
+        "adr",
+        "flags",
+        "events",
+        "facts",
+        "symbols",
+    ];
+    for (const key of keys) {
+        const raw = paths[key] ?? DEFAULT_SYNC_PATHS[key];
+        if (!raw)
+            return false;
+        const normalized = raw.replace(/\/+$|\s+$/g, "");
+        const isFile = normalized.endsWith(".yaml") || normalized.endsWith(".yml");
+        if (isFile) {
+            if (!fs.existsSync(path.resolve(cwd, normalized)))
+                return false;
+        }
+        else {
+            const root = stripToRoot(normalized);
+            if (!fs.existsSync(path.resolve(cwd, root)))
+                return false;
+        }
+    }
+    return true;
+}
+/** Classify activation readiness for autopilot. */
+// implements REQ-mcp-init-kibi-autopilot-v1
+export async function classifyActivationState(workspaceRoot, prolog) {
+    const hasRootConfig = rootKbConfigExists(workspaceRoot);
+    const vendored = findVendoredTrees(workspaceRoot);
+    if (!hasRootConfig && vendored.length > 0) {
+        return "vendored_only";
+    }
+    if (!hasRootConfig) {
+        return "root_uninitialized";
+    }
+    // Root config exists → check targets
+    const allResolve = rootTargetsAllResolve(workspaceRoot);
+    if (!allResolve)
+        return "root_partial";
+    // Config exists and targets resolve — consult KB counts via Prolog
+    try {
+        const payload = await runJsonModuleQuery(prolog, "discovery.pl", "discovery:coverage_report_json(type, [], true, false, 100, 0, JsonString)", "Autopilot activation counts");
+        const rows = payload?.rows ?? [];
+        const counts = {};
+        for (const r of rows)
+            counts[r.type ?? r.id] = Number(r.count || 0);
+        const reqCount = counts.req ?? 0;
+        const nonSymbolTypes = [
+            "req",
+            "scenario",
+            "test",
+            "adr",
+            "flag",
+            "event",
+            "fact",
+        ];
+        const nonSymbolTotal = nonSymbolTypes.reduce((s, t) => s + (counts[t] ?? 0), 0);
+        const scenarioTestAdrFact = (counts.scenario ?? 0) +
+            (counts.test ?? 0) +
+            (counts.adr ?? 0) +
+            (counts.fact ?? 0);
+        if (reqCount >= 1 && nonSymbolTotal >= 5 && scenarioTestAdrFact >= 1) {
+            return "root_active_seeded";
+        }
+        return "root_active_thin";
+    }
+    catch {
+        // If Prolog is unavailable or the query fails, conservatively treat as thin
+        return "root_active_thin";
+    }
+}
+// Recursively collect markdown files under `dir`, excluding known ignore dirs.
+function collectMarkdownFiles(dir, workspaceRoot, vendoredRoots) {
+    const results = [];
+    if (!fs.existsSync(dir))
+        return results;
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory())
+        return results;
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+        const full = path.join(dir, entry);
+        // Skip ignores
+        if (entry === ".git" || entry === "node_modules" || entry === ".kb")
+            continue;
+        // Skip vendored roots
+        const rel = path.relative(workspaceRoot, full).split(path.sep).join("/");
+        if (vendoredRoots.some((v) => rel === v || rel.startsWith(`${v}/`)))
+            continue;
+        const st = fs.statSync(full);
+        if (st.isDirectory()) {
+            results.push(...collectMarkdownFiles(full, workspaceRoot, vendoredRoots));
+            continue;
+        }
+        if (st.isFile() && entry.endsWith(".md")) {
+            results.push(path.relative(workspaceRoot, full).split(path.sep).join("/"));
+        }
+    }
+    return results;
+}
+/** 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;
+    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("/"));
+            }
+            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 },
+    };
+}