kibi-cli 0.18.1 → 1.0.1

package/dist/intent-search.js

@@ -0,0 +1,433 @@
+import path from "node:path";
+import { escapeAtom, parseTriples } from "./prolog/codec.js";
+import { loadEntities, } from "./public/operations/discovery-entities.js";
+import { loadMarkdownBody } from "./search-ranking.js";
+const GRAPH_RELATIONSHIPS = [
+    "implements",
+    "covered_by",
+    "executable_for",
+    "specified_by",
+    "verified_by",
+    "validates",
+    "constrains",
+    "requires_property",
+    "requires_predicate",
+    "requires_rule",
+];
+const FACET_NAMES = [
+    "actors",
+    "actions",
+    "objects",
+    "constraints",
+    "aliases",
+];
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "be",
+    "by",
+    "for",
+    "in",
+    "is",
+    "of",
+    "on",
+    "or",
+    "the",
+    "to",
+    "with",
+]);
+const MAX_CANDIDATES = 10_000;
+const MAX_GRAPH_SEEDS = 5;
+const MAX_GRAPH_EDGES = 2_000;
+function normalize(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[-_]+/g, " ")
+        .replace(/[^a-z0-9\s]+/g, " ")
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((token) => token.length > 4 && token.endsWith("s") && !token.endsWith("ss")
+        ? token.slice(0, -1)
+        : token)
+        .join(" ");
+}
+function tokens(value) {
+    return Array.from(new Set(normalize(value)
+        .split(" ")
+        .filter((token) => token.length > 0 && !STOP_WORDS.has(token))));
+}
+function stringValues(value) {
+    if (typeof value === "string")
+        return value.trim() ? [value] : [];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function entityText(entity) {
+    const fields = [
+        entity.title,
+        entity.id,
+        entity.type,
+        entity.source,
+        entity.sourceFile,
+        entity.semantic_text,
+        entity.text_ref,
+        ...stringValues(entity.tags),
+    ];
+    return fields
+        .filter((field) => typeof field === "string")
+        .join(" ");
+}
+function entitySourcePath(entity) {
+    const sourceFile = entity.sourceFile;
+    if (typeof sourceFile === "string" && sourceFile.trim()) {
+        return sourceFile.split("#", 1)[0]?.trim() ?? null;
+    }
+    const source = entity.source;
+    if (typeof source !== "string" || !source.trim())
+        return null;
+    return source.split("#", 1)[0]?.trim() ?? null;
+}
+function sourcePathMatches(entityPath, requestedPath) {
+    if (!entityPath)
+        return false;
+    const normalizePath = (value) => value.replaceAll("\\", "/").replace(/^\.\//, "");
+    const left = normalizePath(entityPath);
+    const right = normalizePath(requestedPath);
+    return (left === right || left.endsWith(`/${right}`) || right.endsWith(`/${left}`));
+}
+function numberField(entity, ...keys) {
+    for (const key of keys) {
+        const value = entity[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && /^\d+$/.test(value))
+            return Number(value);
+    }
+    return null;
+}
+function sourceMatches(entity, locations) {
+    if (locations.length === 0)
+        return [];
+    const entityPath = entitySourcePath(entity);
+    const title = typeof entity.title === "string" ? normalize(entity.title) : "";
+    const matches = [];
+    for (const location of locations) {
+        if (!sourcePathMatches(entityPath, location.path))
+            continue;
+        const requestedSymbol = location.symbol ? normalize(location.symbol) : "";
+        const symbolMatches = requestedSymbol.length === 0 ||
+            title === requestedSymbol ||
+            title.includes(requestedSymbol) ||
+            requestedSymbol.includes(title);
+        if (!symbolMatches)
+            continue;
+        const startLine = numberField(entity, "sourceLine", "source_line");
+        const endLine = numberField(entity, "sourceEndLine", "source_end_line") ?? startLine;
+        const lineMatches = location.line === undefined ||
+            (startLine !== null &&
+                endLine !== null &&
+                location.line >= startLine &&
+                location.line <= endLine);
+        if (!lineMatches)
+            continue;
+        const exactSymbol = requestedSymbol.length > 0 && title === requestedSymbol;
+        const coordinate = location.line !== undefined && startLine !== null;
+        matches.push({
+            path: location.path,
+            ...(typeof entity.id === "string" ? { symbolId: entity.id } : {}),
+            ...(exactSymbol
+                ? { distance: 0 }
+                : coordinate
+                    ? { distance: 1 }
+                    : { distance: 2 }),
+        });
+    }
+    return matches;
+}
+function facetValues(facets) {
+    const result = [];
+    for (const name of FACET_NAMES) {
+        for (const value of stringValues(facets?.[name])) {
+            if (value.trim())
+                result.push({ name, value });
+        }
+    }
+    return result;
+}
+function scoreEntity(entity, queryTokens, facets, sourceEvidence, graphEvidence, documentFrequency, documentCount, body) {
+    const title = normalize(String(entity.title ?? ""));
+    const metadata = normalize([
+        entity.id,
+        entity.type,
+        entity.source,
+        entity.sourceFile,
+        entity.semantic_text,
+        entity.text_ref,
+        ...stringValues(entity.tags),
+    ]
+        .filter((value) => typeof value === "string")
+        .join(" "));
+    const bodyText = normalize(body ?? "");
+    const titleTokens = new Set(tokens(title));
+    const metadataTokens = new Set(tokens(metadata));
+    const bodyTokens = new Set(tokens(bodyText));
+    const allSignalTokens = Array.from(new Set(queryTokens));
+    const lexical = allSignalTokens.reduce((sum, token) => {
+        const frequency = documentFrequency.get(token) ?? 0;
+        const idf = Math.log(1 + (documentCount + 1) / (frequency + 1));
+        const fieldWeight = titleTokens.has(token)
+            ? 3
+            : metadataTokens.has(token)
+                ? 1.5
+                : bodyTokens.has(token)
+                    ? 0.75
+                    : 0;
+        return sum + idf * fieldWeight;
+    }, 0);
+    const lexicalMax = Math.max(1, allSignalTokens.length * 4);
+    const lexicalScore = Math.min(1, lexical / lexicalMax);
+    const matchedFacets = [];
+    let facetScore = 0;
+    for (const facet of facets) {
+        const facetTokens = tokens(facet.value);
+        if (facetTokens.length === 0)
+            continue;
+        const matches = facetTokens.filter((token) => titleTokens.has(token) ||
+            metadataTokens.has(token) ||
+            bodyTokens.has(token)).length;
+        if (matches > 0) {
+            matchedFacets.push(`${facet.name}:${facet.value}`);
+            facetScore += matches / facetTokens.length;
+        }
+    }
+    facetScore = Math.min(1, facetScore / Math.max(1, facets.length));
+    const sourceScore = sourceEvidence.length > 0 ? 1 : 0;
+    const graphScore = graphEvidence.length > 0 ? Math.min(1, graphEvidence.length / 2) : 0;
+    const score = Math.min(1, lexicalScore * 0.58 +
+        facetScore * 0.17 +
+        sourceScore * 0.2 +
+        graphScore * 0.05);
+    const reasons = [];
+    if (lexicalScore > 0)
+        reasons.push("intent token match");
+    if (matchedFacets.length > 0)
+        reasons.push("semantic facet match");
+    if (sourceEvidence.length > 0)
+        reasons.push("source location match");
+    if (graphEvidence.length > 0)
+        reasons.push("traceability graph match");
+    if (body &&
+        bodyTokens.size > 0 &&
+        queryTokens.some((token) => bodyTokens.has(token))) {
+        reasons.push("markdown body match");
+    }
+    return { score, reasons, matchedFacets };
+}
+function buildDocumentFrequency(entities) {
+    const frequency = new Map();
+    for (const entity of entities) {
+        const seen = new Set(tokens(entityText(entity)));
+        for (const token of seen)
+            frequency.set(token, (frequency.get(token) ?? 0) + 1);
+    }
+    return frequency;
+}
+// implements REQ-kibi-intent-aware-source-discovery
+export async function rankIntentEntities(entities, options, workspaceRoot, graphEdges = []) {
+    const queryTokens = tokens(options.query);
+    const facets = facetValues(options.semanticFacets);
+    const allTokens = Array.from(new Set([
+        ...queryTokens,
+        ...facets.flatMap((facet) => tokens(facet.value)),
+    ]));
+    const documentFrequency = buildDocumentFrequency(entities);
+    const ranked = [];
+    const minScore = options.minScore ?? 0.18;
+    const graphByEntity = new Map();
+    for (const edge of graphEdges) {
+        const pathValue = {
+            from: edge.from,
+            relationships: [edge.relationship],
+            to: edge.to,
+        };
+        const fromPaths = graphByEntity.get(edge.from) ?? [];
+        fromPaths.push(pathValue);
+        graphByEntity.set(edge.from, fromPaths);
+        const toPaths = graphByEntity.get(edge.to) ?? [];
+        toPaths.push(pathValue);
+        graphByEntity.set(edge.to, toPaths);
+    }
+    for (const entity of entities) {
+        const sourceEvidence = sourceMatches(entity, options.sourceLocations ?? []);
+        const entityId = String(entity.id ?? "");
+        // Keep evidence useful for agents and bounded for transport. The score is
+        // already capped; unbounded parallel paths only add noise to receipts.
+        const graphEvidence = (graphByEntity.get(entityId) ?? []).slice(0, 8);
+        const body = await loadMarkdownBody(String(entity.source ?? ""), workspaceRoot);
+        const scored = scoreEntity(entity, allTokens, facets, sourceEvidence, graphEvidence, documentFrequency, entities.length, body);
+        if (scored.score < minScore)
+            continue;
+        const snippet = body
+            ?.split(/\r?\n/)
+            .map((line) => line.trim())
+            .find(Boolean);
+        ranked.push({
+            entity,
+            score: scored.score,
+            reasons: Array.from(new Set(scored.reasons)),
+            ...(snippet !== undefined ? { snippet } : {}),
+            evidence: {
+                normalizedScore: scored.score,
+                matchedFacets: scored.matchedFacets,
+                sourceMatches: sourceEvidence,
+                graphPaths: graphEvidence,
+                abstentionEligible: scored.score < minScore,
+            },
+        });
+    }
+    ranked.sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        const typeOrder = String(left.entity.type ?? "").localeCompare(String(right.entity.type ?? ""));
+        if (typeOrder !== 0)
+            return typeOrder;
+        return String(left.entity.id ?? "").localeCompare(String(right.entity.id ?? ""));
+    });
+    const topScore = ranked[0]?.score ?? null;
+    const first = ranked[0];
+    const second = ranked[1];
+    const topTwoMargin = first !== undefined && second !== undefined
+        ? first.score - second.score
+        : null;
+    return {
+        matches: ranked,
+        analysis: {
+            rankingMode: "intent-v1",
+            candidateCount: entities.length,
+            acceptedCount: ranked.length,
+            topScore,
+            topTwoMargin,
+            abstained: ranked.length === 0,
+        },
+    };
+}
+function graphGoal(seedIds, depth) {
+    const ids = seedIds.map((id) => `'${escapeAtom(id)}'`).join(",");
+    const relationships = GRAPH_RELATIONSHIPS.join(",");
+    if (depth === 1) {
+        return `findall([Rel,From,To], (member(Rel, [${relationships}]), kb_relationship(Rel, From, To), (member(From, [${ids}]); member(To, [${ids}]))), Edges)`;
+    }
+    return `findall([Rel,From,To], (member(Rel, [${relationships}]), kb_relationship(Rel, From, To), (member(From, [${ids}]); member(To, [${ids}]))), Edges)`;
+}
+async function queryGraphEdges(prolog, seedIds) {
+    if (seedIds.length === 0)
+        return [];
+    const result = await prolog.query(graphGoal(seedIds, 1));
+    if (!result.success)
+        return [];
+    return parseTriples(result.bindings.Edges ?? "[]")
+        .slice(0, MAX_GRAPH_EDGES)
+        .map(([relationship, from, to]) => ({ relationship, from, to }));
+}
+async function loadIntentCandidates(prolog, options) {
+    const terms = [
+        options.query,
+        ...facetValues(options.semanticFacets).map((facet) => facet.value),
+    ].filter((term, index, all) => term.trim() && all.indexOf(term) === index);
+    const candidates = new Map();
+    if (prolog.searchEntities &&
+        (options.sourceLocations === undefined ||
+            options.sourceLocations.length === 0)) {
+        for (const term of terms) {
+            const page = await prolog.searchEntities({
+                query: term,
+                ...(options.type !== undefined ? { type: options.type } : {}),
+                limit: MAX_CANDIDATES,
+                offset: 0,
+            });
+            for (const entity of page.entities) {
+                candidates.set(`${String(entity.type ?? "")}::${String(entity.id ?? "")}`, { ...entity });
+            }
+        }
+        // An unfamiliar host-agent alias may not exist in the lexical index at
+        // all. For small facet-bearing corpora, scan the bounded entity set so a
+        // zero lexical hit does not turn a valid semantic query into a false
+        // abstention. Large repositories remain index-bounded.
+        if (facetValues(options.semanticFacets).length > 0 &&
+            candidates.size < 20) {
+            const all = await loadEntities(prolog, options.type ? { type: options.type } : {});
+            for (const entity of all.slice(0, MAX_CANDIDATES)) {
+                candidates.set(`${String(entity.type ?? "")}::${String(entity.id ?? "")}`, entity);
+            }
+        }
+    }
+    else {
+        const all = await loadEntities(prolog, options.type ? { type: options.type } : {});
+        for (const entity of all) {
+            candidates.set(`${String(entity.type ?? "")}::${String(entity.id ?? "")}`, entity);
+        }
+    }
+    if (candidates.size > MAX_CANDIDATES) {
+        return Array.from(candidates.values()).slice(0, MAX_CANDIDATES);
+    }
+    return Array.from(candidates.values());
+}
+// implements REQ-kibi-intent-aware-source-discovery
+export async function executeIntentSearch(options, prolog, workspaceRoot) {
+    const candidates = await loadIntentCandidates(prolog, options);
+    const firstPass = await rankIntentEntities(candidates, options, workspaceRoot);
+    const sourceSeeds = firstPass.matches
+        .filter((match) => match.evidence.sourceMatches.length > 0)
+        .map((match) => String(match.entity.id ?? ""));
+    const seeds = Array.from(new Set([
+        ...(sourceSeeds.length > 0
+            ? sourceSeeds
+            : firstPass.matches
+                .map((match) => String(match.entity.id ?? ""))
+                .slice(0, MAX_GRAPH_SEEDS)),
+    ])).slice(0, MAX_GRAPH_SEEDS);
+    const graphEdges = await queryGraphEdges(prolog, seeds);
+    const knownIds = new Set(candidates.map((entity) => `${String(entity.type ?? "")}::${String(entity.id ?? "")}`));
+    const relatedIds = Array.from(new Set(graphEdges.flatMap((edge) => [edge.from, edge.to]))).filter((id) => !seeds.includes(id));
+    for (const id of relatedIds.slice(0, MAX_GRAPH_SEEDS * 4)) {
+        const related = await loadEntities(prolog, { id });
+        for (const entity of related) {
+            const key = `${String(entity.type ?? "")}::${String(entity.id ?? "")}`;
+            if (!knownIds.has(key)) {
+                knownIds.add(key);
+                candidates.push(entity);
+            }
+        }
+    }
+    return rankIntentEntities(candidates, options, workspaceRoot, graphEdges);
+}
+// implements REQ-kibi-intent-aware-source-discovery
+export function validateIntentSearchInput(input) {
+    if (!input.query.trim())
+        throw new Error("Search execution failed: query must be a non-empty string");
+    if (input.minScore !== undefined &&
+        (!Number.isFinite(input.minScore) ||
+            input.minScore < 0 ||
+            input.minScore > 1)) {
+        throw new Error("Search execution failed: minScore must be between 0 and 1");
+    }
+    for (const location of input.sourceLocations ?? []) {
+        if (!location.path.trim() ||
+            path.isAbsolute(location.path) ||
+            location.path.split("/").includes("..")) {
+            throw new Error("Search execution failed: sourceLocations.path must be workspace-relative");
+        }
+        if (location.line !== undefined &&
+            (!Number.isInteger(location.line) || location.line < 1)) {
+            throw new Error("Search execution failed: sourceLocations.line must be a positive integer");
+        }
+        if (location.column !== undefined &&
+            (!Number.isInteger(location.column) || location.column < 1)) {
+            throw new Error("Search execution failed: sourceLocations.column must be a positive integer");
+        }
+    }
+}

package/dist/operations/bootstrap/activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/activation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAGjF,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,YAAY,CAAC;AAmHpE,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAwE3B"}

package/dist/operations/{autopilot → bootstrap}/activation.js

@@ -1,13 +1,18 @@
 import path from "node:path";
+import { readKbManifestStatus } from "../../utils/kb-manifest.js";
+import { KB_PATHS } from "../../utils/kb-paths.js";
 function activationFor(state) {
     switch (state) {
         case "root_uninitialized":
             return {
                 activationState: state,
                 activationMode: "cold_start_bootstrap",
-                applyBlocked: false,
+                applyBlocked: true,
+                // Discovery remains useful for explaining the next step, but the
+                // resulting plan is blocked until `kibi init` establishes the root.
                 allowCandidateGeneration: true,
-                reason: "Workspace has no attached root KB yet; run a cold-start bootstrap scan across repository evidence.",
+                reason: "Workspace has no attached root KB yet; run `kibi init` before planning bootstrap knowledge.",
+                handoffMessage: "Kibi infrastructure is not initialized. Run `kibi init`, then ask the agent to bootstrap this repository.",
             };
         case "root_partial":
             return {
@@ -29,11 +34,10 @@ function activationFor(state) {
         case "root_active_thin":
             return {
                 activationState: state,
-                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 sparse KB coverage and continue with a handoff.",
+                activationMode: "attached_thin_bootstrap",
+                applyBlocked: false,
+                allowCandidateGeneration: true,
+                reason: "Workspace has an attached but unseeded KB; deterministic bootstrap planning is eligible.",
             };
         case "root_active_seeded":
             return {
@@ -74,38 +78,51 @@ function coverageState(rows) {
         ? "root_active_seeded"
         : "root_active_thin";
 }
+function sourceCoverageState(files) {
+    const counts = {
+        req: files.filter((file) => /^\.kb\/requirements\/.*\.md$/i.test(file))
+            .length,
+        scenario: files.filter((file) => /^\.kb\/scenarios\/.*\.md$/i.test(file))
+            .length,
+        test: files.filter((file) => /^\.kb\/tests\/.*\.md$/i.test(file)).length,
+        adr: files.filter((file) => /^\.kb\/adrs?\/.*\.md$/i.test(file)).length,
+        flag: files.filter((file) => /^\.kb\/flags\/.*\.md$/i.test(file)).length,
+        event: files.filter((file) => /^\.kb\/events\/.*\.md$/i.test(file)).length,
+        fact: files.filter((file) => /^\.kb\/facts\/.*\.md$/i.test(file)).length,
+    };
+    return coverageState(Object.entries(counts).map(([type, count]) => ({ type, count })));
+}
+// implements REQ-KIBI-BOOTSTRAP-PLAN
 export async function classifyActivation(context, files) {
-    const configPath = path.join(context.workspaceRoot, ".kb", "config.json");
-    if (!(await exists(context, configPath))) {
-        const vendored = files.some((file) => file.startsWith("kibi/"));
-        const projectSignal = files.some((file) => !file.startsWith("kibi/") &&
+    // Discovery callers do not all use the same path base.  The CLI globber
+    // returns workspace-relative paths, while host adapters may pass absolute
+    // paths.  Normalize before source-lane classification so a seeded source
+    // KB has the same posture on every peer surface.
+    const normalizedFiles = files.map((file) => {
+        const relative = path.isAbsolute(file)
+            ? path.relative(context.workspaceRoot, file)
+            : file;
+        return relative.replaceAll("\\", "/");
+    });
+    const manifestStatus = readKbManifestStatus(context.workspaceRoot);
+    if (manifestStatus.state === "missing") {
+        const vendored = normalizedFiles.some((file) => file.startsWith("kibi/"));
+        const projectSignalFromFiles = normalizedFiles.some((file) => !file.startsWith("kibi/") &&
             /^(README\.md|package\.json|src\/|app\/|packages\/|tests\/)/.test(file));
+        const projectSignalFromDirectories = await Promise.all(["README.md", "package.json", "src", "app", "packages", "tests"].map((target) => exists(context, path.resolve(context.workspaceRoot, target))));
+        const projectSignal = projectSignalFromFiles || projectSignalFromDirectories.some(Boolean);
         return activationFor(vendored && !projectSignal ? "vendored_only" : "root_uninitialized");
     }
-    let config = {};
-    try {
-        config = JSON.parse((await context.fs?.readFile(configPath)) ?? "{}") ?? {};
-    }
-    catch {
+    if (manifestStatus.state !== "ok")
         return activationFor("root_partial");
-    }
-    const defaults = [
-        "documentation/requirements",
-        "documentation/scenarios",
-        "documentation/tests",
-        "documentation/adr",
-        "documentation/flags",
-        "documentation/events",
-        "documentation/facts",
-        "documentation/symbols.yaml",
-    ];
-    const configured = Object.values(config.paths ?? {});
-    const targets = configured.length >= 8 ? configured : defaults;
-    const resolved = await Promise.all(targets.map((target) => exists(context, path.resolve(context.workspaceRoot, target.replace(/[*?\[].*$/, "").replace(/\/$/, "")))));
+    const targets = [...Object.values(KB_PATHS.lanes), KB_PATHS.symbolsManifest];
+    const resolved = await Promise.all(targets.map((target) => exists(context, path.resolve(context.workspaceRoot, target))));
     if (resolved.some((value) => !value))
         return activationFor("root_partial");
     if (!context.prolog)
-        return activationFor("root_active_thin");
+        return activationFor(normalizedFiles.some((file) => file.startsWith(".kb/"))
+            ? sourceCoverageState(normalizedFiles)
+            : "root_active_thin");
     try {
         const result = await context.prolog.query("discovery:coverage_report_json(type, [], true, false, 100, 0, JsonString)");
         const parsed = JSON.parse(result.bindings.JsonString ?? '{"rows":[]}');

package/dist/operations/{autopilot → bootstrap}/candidate-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"candidate-helpers.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/candidate-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,MAAM,CAMtD;AAED,wBAAgB,MAAM,CACpB,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAA;CAAE,EAE5D,MAAM,EAAE,CAAC,EACT,aAAa,GAAE,SAAS;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,EAAO,GACP,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQnC;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,cAAc,GACvB,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAmC9C"}
+{"version":3,"file":"candidate-helpers.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/candidate-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,MAAM,CAMtD;AAED,wBAAgB,MAAM,CACpB,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAA;CAAE,EAE5D,MAAM,EAAE,CAAC,EACT,aAAa,GAAE,SAAS;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,EAAO,GACP,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQnC;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,cAAc,GACvB,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAmC9C"}

package/dist/operations/bootstrap/candidates.d.ts

@@ -0,0 +1,4 @@
+import { type CandidateBuildResult } from "./markdown-candidates.js";
+import type { BootstrapEvidence } from "./types.js";
+export declare function buildBootstrapCandidates(evidence: readonly BootstrapEvidence[], existingIds: ReadonlySet<string>, minConfidence: number, includeGenericMarkdown: boolean): CandidateBuildResult;
+//# sourceMappingURL=candidates.d.ts.map

package/dist/operations/{autopilot → bootstrap}/candidates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/candidates.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAmHpB,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,EACtC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,sBAAsB,EAAE,OAAO,GAC9B,oBAAoB,CAqBtB"}
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/candidates.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAmHpB,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,EACtC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,sBAAsB,EAAE,OAAO,GAC9B,oBAAoB,CAsCtB"}

package/dist/operations/{autopilot → bootstrap}/candidates.js

@@ -57,10 +57,9 @@ function providerCandidate(item, existingIds, minConfidence) {
     const symbolTitle = item.kind === "source_symbols" && /\.(?:[cm]?[jt]sx?)$/i.test(relativePath)
         ? `Source symbols: ${path.basename(relativePath, path.extname(relativePath))}`
         : undefined;
-    const title = symbolTitle ??
-        (typeof item.data.title === "string"
-            ? item.data.title
-            : `Autopilot evidence from ${relativePath}`);
+    const title = (typeof item.data.title === "string" ? item.data.title : undefined) ??
+        symbolTitle ??
+        `Bootstrap evidence from ${relativePath}`;
     const entity = {
         type: "fact",
         id,
@@ -71,12 +70,12 @@ function providerCandidate(item, existingIds, minConfidence) {
             : item.kind === "repo_metadata"
                 ? "meta"
                 : "observation",
-        source: `autopilot:${item.provider}:${relativePath}`,
+        source: `bootstrap:${item.provider}:${relativePath}`,
         text_ref: relativePath,
     };
     const evidence = Array.isArray(item.data.evidence)
         ? item.data.evidence.filter((value) => typeof value === "string")
-        : [`provider:${item.provider}`];
+        : [`provider:${item.provider}`, `${item.provider}:${relativePath}`];
     return [
         {
             candidateId: `prov:${item.kind}:${slug(relativePath, 96) || "evidence"}`,
@@ -92,8 +91,9 @@ function providerCandidate(item, existingIds, minConfidence) {
         },
     ];
 }
-// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
-export function buildAutopilotCandidates(evidence, existingIds, minConfidence, includeGenericMarkdown) {
+// implements REQ-mcp-kibi-bootstrap-bootstrap-v1, REQ-kibi-operation-interface-parity
+// implements REQ-KIBI-BOOTSTRAP-PLAN
+export function buildBootstrapCandidates(evidence, existingIds, minConfidence, includeGenericMarkdown) {
     const candidates = [];
     const sourceOnlySignals = [];
     for (const item of evidence) {
@@ -104,6 +104,20 @@ export function buildAutopilotCandidates(evidence, existingIds, minConfidence, i
             candidates.push(...built.candidates);
             sourceOnlySignals.push(...built.sourceOnlySignals);
         }
+        if (item.kind === "test_topology") {
+            const confidence = typeof item.data.confidence === "number" ? item.data.confidence : 0.8;
+            if (confidence >= minConfidence) {
+                sourceOnlySignals.push({
+                    kind: "test",
+                    title: `Author TEST coverage for ${item.label}`,
+                    sourcePath: item.absolutePath ?? item.relativePath ?? item.label,
+                    confidence,
+                    evidence: Array.isArray(item.data.evidence)
+                        ? item.data.evidence.filter((value) => typeof value === "string")
+                        : [`test_topology:${item.relativePath ?? item.label}`],
+                });
+            }
+        }
         candidates.push(...providerCandidate(item, existingIds, minConfidence));
     }
     return {

package/dist/operations/{autopilot → bootstrap}/discovery-evidence.d.ts

@@ -1,9 +1,9 @@
 import type { OperationContext } from "../../public/operations/runtime-types.js";
-import type { AutopilotEvidence } from "./types.js";
+import type { BootstrapEvidence } from "./types.js";
 export type EvidenceScan = {
     readonly files: readonly string[];
     readonly ignoredSources: readonly string[];
-    readonly evidence: readonly AutopilotEvidence[];
+    readonly evidence: readonly BootstrapEvidence[];
     readonly warnings: readonly string[];
 };
 export declare function scanEvidence(context: OperationContext): Promise<EvidenceScan>;

package/dist/operations/{autopilot → bootstrap}/discovery-evidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-evidence.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/discovery-evidence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AA0BpB,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,CAAC;AA8HF,wBAAsB,YAAY,CAChC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CAqDvB"}
+{"version":3,"file":"discovery-evidence.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/discovery-evidence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AA0BpB,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,CAAC;AAoKF,wBAAsB,YAAY,CAChC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CA4DvB"}