kibi-cli 0.14.0 → 0.16.1

package/dist/extractors/markdown.js

@@ -19,6 +19,7 @@ import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import Ajv from "ajv";
 import { load as yamlLoad } from "js-yaml";
+import { semanticClaimKey } from "../operations/semantic-advisor/clauses.js";
 import entitySchema from "../schemas/entity.schema.json" with { type: "json" };
 // Typed fact field constants for extraction
 const FACT_STRING_FIELDS = [
@@ -34,13 +35,30 @@ const FACT_STRING_FIELDS = [
     "valid_from",
     "valid_to",
     "canonical_key",
+    "claim_key",
+    "claim_text",
+    "predicate_name",
+    "predicate_namespace",
+];
+const FACT_NUMBER_FIELDS = [
+    "value_int",
+    "value_number",
+    "predicate_arity",
 ];
-const FACT_NUMBER_FIELDS = ["value_int", "value_number"];
 const FACT_BOOLEAN_FIELDS = ["value_bool", "closed_world"];
+const FACT_STRING_ARRAY_FIELDS = [
+    "argument_names",
+    "argument_types",
+    "argument_descriptions",
+    "aliases",
+    "examples",
+    "predicate_args",
+];
 const FACT_ONLY_FIELDS = [
     ...FACT_STRING_FIELDS,
     ...FACT_NUMBER_FIELDS,
     ...FACT_BOOLEAN_FIELDS,
+    ...FACT_STRING_ARRAY_FIELDS,
 ];
 const TEST_ENUM_FIELDS = [
     "verification_scope",
@@ -345,6 +363,9 @@ function extractFromMarkdownContent(content, filePath) {
             entity.severity = data.severity;
         if (data.text_ref !== undefined)
             entity.text_ref = data.text_ref;
+        if (type === "req" && Array.isArray(data.logic_claims)) {
+            entity.logic_claims = data.logic_claims.filter((value) => typeof value === "string");
+        }
         if (type !== "fact") {
             const invalidFactField = FACT_ONLY_FIELDS.find((field) => data[field] !== undefined);
             if (invalidFactField) {
@@ -417,6 +438,11 @@ function extractFromMarkdownContent(content, filePath) {
                     entity[field] = data[field];
                 }
             }
+            for (const field of FACT_STRING_ARRAY_FIELDS) {
+                if (Array.isArray(data[field])) {
+                    entity[field] = data[field].filter((value) => typeof value === "string");
+                }
+            }
         }
         if (!validateExtractedEntity(entity)) {
             const messages = (validateExtractedEntity.errors || [])
@@ -427,6 +453,17 @@ function extractFromMarkdownContent(content, filePath) {
                 hint: "Fix the entity fields so they match the public schema.",
             });
         }
+        if (entity.type === "fact" &&
+            entity.claim_key !== undefined &&
+            entity.claim_text !== undefined) {
+            const expectedClaimKey = semanticClaimKey(entity.claim_text);
+            if (entity.claim_key !== expectedClaimKey) {
+                throw new FrontmatterError(`Entity validation failed: claim_key must equal the stable key derived from claim_text (expected '${expectedClaimKey}')`, filePath, {
+                    classification: "Logical Claim Provenance Mismatch",
+                    hint: "Use the claim_key returned by kb_semantic_advisor for this exact atomic clause.",
+                });
+            }
+        }
         return {
             entity,
             relationships,

package/dist/extractors/symbols-ts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbols-ts.d.ts","sourceRoot":"","sources":["../../src/extractors/symbols-ts.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,sBAAsB,EAIvB,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAcD,wBAAgB,mCAAmC,IAAI,sBAAsB,CA+B5E;AAED,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,mBAAmB,EAAE,EAC9B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAuEhC"}
+{"version":3,"file":"symbols-ts.d.ts","sourceRoot":"","sources":["../../src/extractors/symbols-ts.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EACV,sBAAsB,EAIvB,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAcD,wBAAgB,mCAAmC,IAAI,sBAAsB,CA+B5E;AAED,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,mBAAmB,EAAE,EAC9B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAuEhC"}

package/dist/extractors/symbols-ts.js

@@ -17,7 +17,7 @@
 */
 import { access, readFile } from "node:fs/promises";
 import * as path from "node:path";
-import { Project, ScriptKind, } from "ts-morph";
+import { Project, ScriptKind, SyntaxKind, } from "ts-morph";
 const SUPPORTED_SOURCE_EXTENSIONS = new Set([
     ".ts",
     ".tsx",
@@ -189,12 +189,16 @@ function collectSourceSymbols(sourceFile) {
             .map((doc) => doc.getFullText())
             .join("\n")));
         for (const method of decl.getMethods()) {
+            if (isPrivateClassMember(method))
+                continue;
             symbols.push(toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(decl.getName(), method.getName()), "method", method.getNameNode() ?? method, method, `${method.getFullText()}\n${method
                 .getJsDocs()
                 .map((doc) => doc.getFullText())
                 .join("\n")}`));
         }
         for (const property of decl.getProperties()) {
+            if (isPrivateClassMember(property))
+                continue;
             symbols.push(toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(decl.getName(), property.getName()), "property", property.getNameNode() ?? property, property, `${property.getFullText()}\n${property
                 .getJsDocs()
                 .map((doc) => doc.getFullText())
@@ -204,6 +208,8 @@ function collectSourceSymbols(sourceFile) {
             ...decl.getGetAccessors(),
             ...decl.getSetAccessors(),
         ]) {
+            if (isPrivateClassMember(accessor))
+                continue;
             symbols.push(toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(decl.getName(), accessor.getName()), "accessor", accessor.getNameNode() ?? accessor, accessor, `${accessor.getFullText()}\n${accessor
                 .getJsDocs()
                 .map((doc) => doc.getFullText())
@@ -234,6 +240,10 @@ function collectSourceSymbols(sourceFile) {
     }
     return symbols;
 }
+function isPrivateClassMember(member) {
+    return (member.hasModifier(SyntaxKind.PrivateKeyword) ||
+        member.getName().startsWith("#"));
+}
 function toSourceSymbolAnalysis(sourceFile, name, kind, startNode, endNode, directiveText) {
     const start = sourceFile.getLineAndColumnAtPos(startNode.getStart());
     const end = sourceFile.getLineAndColumnAtPos(endNode.getEnd());

package/dist/operations/autopilot/activation.d.ts

@@ -0,0 +1,4 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { ActivationPolicy } from "./types.js";
+export declare function classifyActivation(context: OperationContext, files: readonly string[]): Promise<ActivationPolicy>;
+//# sourceMappingURL=activation.d.ts.map

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

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

package/dist/operations/autopilot/activation.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+function activationFor(state) {
+    switch (state) {
+        case "root_uninitialized":
+            return {
+                activationState: state,
+                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.",
+            };
+        case "root_partial":
+            return {
+                activationState: state,
+                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 "vendored_only":
+            return {
+                activationState: state,
+                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_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.",
+            };
+        case "root_active_seeded":
+            return {
+                activationState: state,
+                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 existing KB context instead of generating bootstrap candidates.",
+            };
+    }
+}
+async function exists(context, target) {
+    try {
+        await context.fs?.stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function coverageState(rows) {
+    const counts = Object.fromEntries(rows.map((row) => [row.type, Number(row.count)]));
+    const nonSymbols = [
+        "req",
+        "scenario",
+        "test",
+        "adr",
+        "flag",
+        "event",
+        "fact",
+    ].reduce((sum, type) => sum + Number(counts[type] ?? 0), 0);
+    const supporting = Number(counts.scenario ?? 0) +
+        Number(counts.test ?? 0) +
+        Number(counts.adr ?? 0) +
+        Number(counts.fact ?? 0);
+    return Number(counts.req ?? 0) >= 1 && nonSymbols >= 5 && supporting >= 1
+        ? "root_active_seeded"
+        : "root_active_thin";
+}
+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/") &&
+            /^(README\.md|package\.json|src\/|app\/|packages\/|tests\/)/.test(file));
+        return activationFor(vendored && !projectSignal ? "vendored_only" : "root_uninitialized");
+    }
+    let config = {};
+    try {
+        config = JSON.parse((await context.fs?.readFile(configPath)) ?? "{}") ?? {};
+    }
+    catch {
+        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(/\/$/, "")))));
+    if (resolved.some((value) => !value))
+        return activationFor("root_partial");
+    if (!context.prolog)
+        return activationFor("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":[]}');
+        const rows = parsed !== null &&
+            typeof parsed === "object" &&
+            "rows" in parsed &&
+            Array.isArray(parsed.rows)
+            ? parsed.rows.flatMap((row) => row !== null &&
+                typeof row === "object" &&
+                "type" in row &&
+                "count" in row &&
+                typeof row.type === "string" &&
+                typeof row.count === "number"
+                ? [{ type: row.type, count: row.count }]
+                : [])
+            : [];
+        return activationFor(coverageState(rows));
+    }
+    catch {
+        return activationFor("root_active_thin");
+    }
+}

package/dist/operations/autopilot/candidate-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { StrictWriteSet } from "../../utils/strict-modeling.js";
+export declare function confidenceBand(value: number): string;
+export declare function slug(value: string, limit?: number): string;
+export declare function upsert<T extends {
+    readonly type?: unknown;
+    readonly id?: unknown;
+}>(entity: T, relationships?: readonly {
+    readonly type: string;
+    readonly from: string;
+    readonly to: string;
+}[]): Readonly<Record<string, unknown>>;
+export declare function strictPlan(writeSet: StrictWriteSet): readonly Readonly<Record<string, unknown>>[];
+//# sourceMappingURL=candidate-helpers.d.ts.map

package/dist/operations/autopilot/candidate-helpers.d.ts.map

@@ -0,0 +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"}

package/dist/operations/autopilot/candidate-helpers.js

@@ -0,0 +1,55 @@
+export function confidenceBand(value) {
+    return value >= 0.9 ? "high" : value >= 0.8 ? "medium" : "low";
+}
+export function slug(value, limit = 80) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "")
+        .slice(0, limit);
+}
+export function upsert(entity, relationships = []) {
+    const { type, id, ...properties } = entity;
+    return {
+        type: String(type ?? ""),
+        id: String(id ?? ""),
+        properties,
+        relationships,
+    };
+}
+export function strictPlan(writeSet) {
+    if (!writeSet.isStrict) {
+        return [
+            {
+                type: "fact",
+                id: writeSet.observationFact.id,
+                properties: writeSet.observationFact.properties,
+                relationships: [],
+            },
+        ];
+    }
+    return [
+        {
+            type: "fact",
+            id: writeSet.subjectFact.id,
+            properties: writeSet.subjectFact.properties,
+            relationships: [],
+        },
+        {
+            type: "fact",
+            id: writeSet.propertyFact.id,
+            properties: writeSet.propertyFact.properties,
+            relationships: [],
+        },
+        {
+            type: "req",
+            id: writeSet.req.id,
+            properties: writeSet.req.properties,
+            relationships: writeSet.relationships.map(({ type, from, to }) => ({
+                type,
+                from,
+                to,
+            })),
+        },
+    ];
+}

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

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

package/dist/operations/autopilot/candidates.d.ts.map

@@ -0,0 +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"}

package/dist/operations/autopilot/candidates.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import { extractFromManifestString } from "../../extractors/manifest.js";
+import { extractFromMarkdownString } from "../../extractors/markdown.js";
+import { confidenceBand, slug, upsert } from "./candidate-helpers.js";
+import { markdownCandidates, } from "./markdown-candidates.js";
+function typedCandidates(item, existingIds) {
+    try {
+        const results = item.kind === "symbol_manifest"
+            ? extractFromManifestString(item.content ?? "", item.relativePath ?? item.label)
+            : [
+                extractFromMarkdownString(item.content ?? "", item.relativePath ?? item.label),
+            ];
+        return results.flatMap(({ entity, relationships }) => {
+            if (existingIds.has(entity.id))
+                return [];
+            const sourceKind = item.kind === "symbol_manifest" ? "symbol_manifest" : "typed_markdown";
+            return [
+                {
+                    candidateId: `${sourceKind === "symbol_manifest" ? "mf" : "md"}:${item.relativePath}:${entity.id}`,
+                    entityType: entity.type,
+                    title: entity.title,
+                    sourceKind,
+                    sourcePath: item.absolutePath ?? item.label,
+                    confidence: sourceKind === "symbol_manifest" ? 0.98 : 1,
+                    confidenceBand: "high",
+                    evidence: [
+                        `extracted_from_${sourceKind}:${item.relativePath}`,
+                        `entity_id:${entity.id}`,
+                    ],
+                    relationships: relationships.map(({ type, from, to }) => ({
+                        type,
+                        from,
+                        to,
+                    })),
+                    applyPlan: [upsert(entity, relationships)],
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function providerCandidate(item, existingIds, minConfidence) {
+    if (!new Set([
+        "repo_metadata",
+        "repo_layout",
+        "test_topology",
+        "source_symbols",
+    ]).has(item.kind))
+        return [];
+    const relativePath = item.relativePath ?? item.label;
+    const confidence = typeof item.data.confidence === "number" ? item.data.confidence : 0.8;
+    const id = `FACT-GEN-${slug(`${item.kind}-${relativePath}`, 64) || "evidence"}`.toUpperCase();
+    if (confidence < minConfidence || existingIds.has(id))
+        return [];
+    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 entity = {
+        type: "fact",
+        id,
+        title,
+        status: "active",
+        fact_kind: typeof item.data.factKind === "string"
+            ? item.data.factKind
+            : item.kind === "repo_metadata"
+                ? "meta"
+                : "observation",
+        source: `autopilot:${item.provider}:${relativePath}`,
+        text_ref: relativePath,
+    };
+    const evidence = Array.isArray(item.data.evidence)
+        ? item.data.evidence.filter((value) => typeof value === "string")
+        : [`provider:${item.provider}`];
+    return [
+        {
+            candidateId: `prov:${item.kind}:${slug(relativePath, 96) || "evidence"}`,
+            entityType: "fact",
+            title,
+            sourceKind: item.kind,
+            sourcePath: item.absolutePath ?? relativePath,
+            confidence,
+            confidenceBand: confidenceBand(confidence),
+            evidence,
+            relationships: [],
+            applyPlan: [upsert(entity)],
+        },
+    ];
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export function buildAutopilotCandidates(evidence, existingIds, minConfidence, includeGenericMarkdown) {
+    const candidates = [];
+    const sourceOnlySignals = [];
+    for (const item of evidence) {
+        if (item.kind === "typed_markdown" || item.kind === "symbol_manifest")
+            candidates.push(...typedCandidates(item, existingIds));
+        if (item.kind === "generic_markdown" && includeGenericMarkdown) {
+            const built = markdownCandidates(item, existingIds, minConfidence);
+            candidates.push(...built.candidates);
+            sourceOnlySignals.push(...built.sourceOnlySignals);
+        }
+        candidates.push(...providerCandidate(item, existingIds, minConfidence));
+    }
+    return {
+        candidates,
+        sourceOnlySignals: sourceOnlySignals.sort((left, right) => right.confidence - left.confidence ||
+            left.sourcePath.localeCompare(right.sourcePath)),
+    };
+}

package/dist/operations/autopilot/discovery-evidence.d.ts

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

package/dist/operations/autopilot/discovery-evidence.d.ts.map

@@ -0,0 +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"}

package/dist/operations/autopilot/discovery-evidence.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { OperationError } from "../../cli-errors.js";
+const SCAN_PATTERNS = [
+    "**/*.md",
+    "**/symbols.{yml,yaml}",
+    "**/package.json",
+    "**/tsconfig*.json",
+    "**/pyproject.toml",
+    "**/Cargo.toml",
+    "**/go.mod",
+    "**/opencode.json",
+    "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+];
+const CODE_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rb|go|rs|java|kt|swift|php|c|cc|cpp|h|hpp)$/i;
+const LAYOUT_ROOTS = new Set([
+    "src",
+    "app",
+    "apps",
+    "packages",
+    "tests",
+    "test",
+    "docs",
+    "scripts",
+]);
+function isScanFilesystem(value) {
+    return Boolean(value && "glob" in value && typeof value.glob === "function");
+}
+function isScanGit(value) {
+    return Boolean(value &&
+        "ignoredPaths" in value &&
+        typeof value.ignoredPaths === "function");
+}
+function classifyFile(relativePath, content) {
+    if (/symbols\.ya?ml$/i.test(relativePath))
+        return ["typed_kibi_docs", "symbol_manifest"];
+    if (/\.md$/i.test(relativePath)) {
+        return /^---\s*[\r\n]/.test(content) &&
+            /(^|\/)documentation\/(requirements|scenarios|tests|adr|flags|events|facts)\//.test(relativePath)
+            ? ["typed_kibi_docs", "typed_markdown"]
+            : ["generic_repo_docs", "generic_markdown"];
+    }
+    if (/(^|\/)(package\.json|tsconfig[^/]*\.json|pyproject\.toml|Cargo\.toml|go\.mod)$/.test(relativePath))
+        return ["repo_metadata", "repo_metadata"];
+    if (/\.(test|spec)\.[^.]+$/i.test(relativePath) ||
+        /(^|\/)__tests__\//.test(relativePath))
+        return ["test_topology", "test_topology"];
+    if (CODE_EXTENSION.test(relativePath))
+        return ["source_symbols", "source_symbols"];
+    return null;
+}
+function evidenceData(provider, relativePath, content) {
+    if (provider === "repo_metadata")
+        return {
+            title: `Repository metadata: ${path.basename(relativePath)}`,
+            factKind: "meta",
+            confidence: relativePath.includes("tsconfig") ? 0.9 : 0.86,
+            evidence: [`repo_metadata:${relativePath}`],
+        };
+    if (provider === "test_topology") {
+        const frameworks = [
+            content.includes("bun:test") ? "bun:test" : "",
+            content.includes("vitest") ? "vitest" : "",
+            content.includes("node:test") ? "node:test" : "",
+        ].filter(Boolean);
+        return {
+            title: `Test topology: ${frameworks.join(", ") || relativePath}`,
+            factKind: "observation",
+            confidence: frameworks.length > 0 ? 0.92 : 0.85,
+            evidence: [
+                `test_topology:${relativePath}`,
+                ...frameworks.map((item) => `framework:${item}`),
+            ],
+            frameworks,
+        };
+    }
+    if (provider === "source_symbols")
+        return {
+            title: `Source module: ${path.basename(relativePath, path.extname(relativePath))}`,
+            factKind: "observation",
+            confidence: 0.82,
+            evidence: [`source_symbols:${relativePath}`],
+        };
+    return {};
+}
+function layoutEvidence(workspaceRoot, files, ignored) {
+    const roots = [
+        ...new Set(files
+            .filter((file) => !ignored.has(file))
+            .map((file) => file.split("/", 1)[0] ?? "")
+            .filter((root) => LAYOUT_ROOTS.has(root))),
+    ];
+    return roots.map((root) => ({
+        provider: "repo_layout",
+        kind: "repo_layout",
+        label: root,
+        relativePath: root,
+        absolutePath: path.join(workspaceRoot, root),
+        data: {
+            title: `Repository layout: ${root} directory`,
+            factKind: "observation",
+            confidence: 0.84,
+            evidence: [`repo_layout:${root}`],
+        },
+    }));
+}
+export async function scanEvidence(context) {
+    const fs = context.fs;
+    const git = context.git;
+    if (!isScanFilesystem(fs) || !isScanGit(git))
+        throw new OperationError("OPERATION_FAILED", "Autopilot requires filesystem glob and git ignore ports.");
+    const files = [
+        ...(await fs.glob(SCAN_PATTERNS, {
+            cwd: context.workspaceRoot,
+            includeIgnored: true,
+        })),
+    ].sort();
+    const ignoredSources = [
+        ...(await git.ignoredPaths(context.workspaceRoot, files)),
+    ].sort();
+    const ignored = new Set(ignoredSources);
+    const evidence = [];
+    const warnings = [];
+    for (const relativePath of files) {
+        if (ignored.has(relativePath))
+            continue;
+        const absolutePath = path.resolve(context.workspaceRoot, relativePath);
+        try {
+            const content = await fs.readFile(absolutePath);
+            const classification = classifyFile(relativePath, content);
+            if (!classification)
+                continue;
+            const [provider, kind] = classification;
+            if (provider === "repo_metadata" &&
+                path.basename(relativePath) === "package.json") {
+                try {
+                    JSON.parse(content);
+                }
+                catch {
+                    warnings.push(`repo_metadata:failed_to_parse:${relativePath}`);
+                }
+            }
+            evidence.push({
+                provider,
+                kind,
+                label: relativePath,
+                relativePath,
+                absolutePath,
+                content,
+                data: evidenceData(provider, relativePath, content),
+            });
+        }
+        catch {
+            warnings.push(`failed_to_read:${relativePath}`);
+        }
+    }
+    evidence.push(...layoutEvidence(context.workspaceRoot, files, ignored));
+    return { files, ignoredSources, evidence, warnings };
+}

package/dist/operations/autopilot/discovery.d.ts

@@ -0,0 +1,4 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import { type DiscoveryResult } from "./types.js";
+export declare function discoverAutopilot(context: OperationContext): Promise<DiscoveryResult>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/operations/autopilot/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/discovery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,YAAY,CAAC;AAwEpB,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA+C1B"}