kibi-cli 0.14.0 → 0.16.1

package/dist/operations/autopilot/discovery.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { getSchemaVersionStatus } from "../../public/schema-version.js";
+import { classifyActivation } from "./activation.js";
+import { scanEvidence } from "./discovery-evidence.js";
+import { AUTOPILOT_PROVIDER_ORDER, } from "./types.js";
+const EXCLUDED_ROOTS = [
+    ".git",
+    ".kb",
+    ".venv",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "target",
+    "third-party",
+    "third_party",
+    "vendor",
+    "vendors",
+    "venv",
+];
+const LANGUAGE_NAMES = {
+    ts: "typescript",
+    tsx: "typescript",
+    mts: "typescript",
+    cts: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+};
+async function migrationWarning(context) {
+    try {
+        const raw = await context.fs?.readFile(path.join(context.workspaceRoot, ".kb", "config.json"));
+        return getSchemaVersionStatus(JSON.parse(raw ?? "{}") ?? undefined).warning;
+    }
+    catch {
+        return null;
+    }
+}
+function languages(evidence) {
+    return [
+        ...new Set(evidence
+            .filter((item) => item.kind === "source_symbols")
+            .map((item) => {
+            const extension = path.extname(item.label).slice(1);
+            return LANGUAGE_NAMES[extension] ?? extension;
+        })),
+    ].sort();
+}
+function frameworks(evidence) {
+    return [
+        ...new Set(evidence.flatMap((item) => Array.isArray(item.data.frameworks)
+            ? item.data.frameworks.filter((value) => typeof value === "string")
+            : [])),
+    ].sort();
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export async function discoverAutopilot(context) {
+    const scan = await scanEvidence(context);
+    const ignored = new Set(scan.ignoredSources);
+    const activation = await classifyActivation(context, scan.files.filter((file) => !ignored.has(file)));
+    const evidence = activation.allowCandidateGeneration
+        ? [...scan.evidence]
+        : [];
+    evidence.sort((left, right) => AUTOPILOT_PROVIDER_ORDER.indexOf(left.provider) -
+        AUTOPILOT_PROVIDER_ORDER.indexOf(right.provider) ||
+        left.label.localeCompare(right.label));
+    const providersRun = activation.allowCandidateGeneration
+        ? [...AUTOPILOT_PROVIDER_ORDER]
+        : [];
+    const providerCounts = Object.fromEntries(AUTOPILOT_PROVIDER_ORDER.map((provider) => [
+        provider,
+        evidence.filter((item) => item.provider === provider).length,
+    ]));
+    return {
+        activation,
+        evidence,
+        ignoredSources: scan.ignoredSources,
+        migrationWarning: await migrationWarning(context),
+        summary: {
+            activationState: activation.activationState,
+            activationMode: activation.activationMode,
+            applyBlocked: activation.applyBlocked,
+            reason: activation.reason,
+            ...(activation.handoffMessage
+                ? { handoffMessage: activation.handoffMessage }
+                : {}),
+            providersRun,
+            providerCounts,
+            detectedLanguages: languages(evidence),
+            detectedTestFrameworks: frameworks(evidence),
+            excludedRoots: [...EXCLUDED_ROOTS].sort(),
+            truncated: false,
+            scanWarnings: [...new Set(scan.warnings)].sort(),
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { AutopilotGenerateArgs, AutopilotGenerateResult, Candidate } from "./types.js";
+export declare function selectAutopilotCandidates(input: readonly Candidate[], existingIds: ReadonlySet<string>, entityTypes: readonly string[] | undefined, maximum: number): {
+    readonly candidates: readonly Candidate[];
+    readonly suppressed: readonly Readonly<Record<string, unknown>>[];
+};
+export declare function executeAutopilotGenerate(args: AutopilotGenerateArgs, context: OperationContext): Promise<AutopilotGenerateResult>;
+//# sourceMappingURL=generate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/generate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,SAAS,EACV,MAAM,YAAY,CAAC;AAsBpB,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd;IACD,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACnE,CAiDA;AAiBD,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,uBAAuB,CAAC,CAgDlC"}

package/dist/operations/autopilot/generate.js

@@ -0,0 +1,112 @@
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+import { buildAutopilotCandidates } from "./candidates.js";
+import { discoverAutopilot } from "./discovery.js";
+import { presentAutopilot } from "./presentation.js";
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(maximum, value));
+}
+function titleKey(candidate) {
+    return `${candidate.entityType}::${candidate.title.trim().toLowerCase().replace(/\s+/g, " ")}`;
+}
+function firstUpsertId(candidate) {
+    const first = candidate.applyPlan[0];
+    if (typeof first?.id === "string")
+        return first.id;
+    const properties = first?.properties;
+    return properties !== null &&
+        typeof properties === "object" &&
+        "id" in properties &&
+        typeof properties.id === "string"
+        ? properties.id
+        : "";
+}
+export function selectAutopilotCandidates(input, existingIds, entityTypes, maximum) {
+    const allowed = entityTypes && entityTypes.length > 0 ? new Set(entityTypes) : null;
+    const sorted = input
+        .filter((candidate) => allowed?.has(candidate.entityType) ?? true)
+        .sort((left, right) => right.confidence - left.confidence ||
+        left.sourcePath.localeCompare(right.sourcePath))
+        .slice(0, maximum);
+    const typedTitles = new Set(sorted
+        .filter((candidate) => candidate.sourceKind === "typed_markdown")
+        .map(titleKey));
+    const selected = new Map();
+    const suppressed = [];
+    const suppress = (candidate, reason) => {
+        suppressed.push({
+            candidateId: candidate.candidateId,
+            reason,
+            sourcePath: candidate.sourcePath,
+            entityType: candidate.entityType,
+        });
+    };
+    for (const candidate of sorted) {
+        if (existingIds.has(firstUpsertId(candidate))) {
+            suppress(candidate, "entity_exists");
+            continue;
+        }
+        const key = titleKey(candidate);
+        if (candidate.sourceKind === "generic_markdown" && typedTitles.has(key)) {
+            suppress(candidate, "shadowed_by_typed_source");
+            continue;
+        }
+        const previous = selected.get(key);
+        if (!previous) {
+            selected.set(key, candidate);
+            continue;
+        }
+        const keepCandidate = candidate.confidence > previous.confidence ||
+            (candidate.confidence === previous.confidence &&
+                candidate.sourcePath < previous.sourcePath);
+        suppress(keepCandidate ? previous : candidate, "duplicate_title");
+        if (keepCandidate)
+            selected.set(key, candidate);
+    }
+    return { candidates: [...selected.values()], suppressed };
+}
+async function existingEntityIds(context) {
+    if (!context.prolog)
+        return new Set();
+    try {
+        const entities = await loadEntities(context.prolog, {});
+        return new Set(entities.map((entity) => String(entity.id ?? "")).filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export async function executeAutopilotGenerate(args, context) {
+    const includeGenericMarkdown = args.includeGenericMarkdown ?? true;
+    const minConfidence = clamp(args.minConfidence ?? 0.8, 0.6, 0.95);
+    const maxCandidates = clamp(Math.trunc(args.maxCandidates ?? 50), 1, 200);
+    const [discovery, existingIds] = await Promise.all([
+        discoverAutopilot(context),
+        existingEntityIds(context),
+    ]);
+    const built = discovery.activation.allowCandidateGeneration
+        ? buildAutopilotCandidates(discovery.evidence, existingIds, minConfidence, includeGenericMarkdown)
+        : { candidates: [], sourceOnlySignals: [] };
+    const filteredSignals = args.entityTypes && args.entityTypes.length > 0
+        ? built.sourceOnlySignals.filter((signal) => args.entityTypes?.includes(signal.kind))
+        : built.sourceOnlySignals;
+    const selected = selectAutopilotCandidates(built.candidates.filter((candidate) => candidate.confidence >= minConfidence), existingIds, args.entityTypes, maxCandidates);
+    const ignored = discovery.ignoredSources.map((sourcePath) => ({
+        candidateId: "",
+        reason: "ignored_source",
+        sourcePath,
+        entityType: "",
+    }));
+    return presentAutopilot({
+        root: context.workspaceRoot,
+        activation: discovery.activation,
+        discoverySummary: discovery.summary,
+        migrationWarning: discovery.migrationWarning,
+        ...(args.bootstrapContext
+            ? { bootstrapContext: args.bootstrapContext }
+            : {}),
+        candidates: selected.candidates,
+        sourceOnlySignals: filteredSignals,
+        suppressedCandidates: [...selected.suppressed, ...ignored],
+    });
+}

package/dist/operations/autopilot/guidance-actions.d.ts

@@ -0,0 +1,3 @@
+import type { ActivationPolicy, AutopilotDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
+export declare function buildActions(root: string, activation: ActivationPolicy, declared: AutopilotDeclaredContext, candidates: readonly Candidate[], signals: readonly SourceOnlySignal[]): readonly Readonly<Record<string, unknown>>[];
+//# sourceMappingURL=guidance-actions.d.ts.map

package/dist/operations/autopilot/guidance-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guidance-actions.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/guidance-actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAgBpB,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,wBAAwB,EAClC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAuE9C"}

package/dist/operations/autopilot/guidance-actions.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+function relative(root, target) {
+    const value = path.relative(root, target);
+    return value.startsWith("..") || path.isAbsolute(value)
+        ? target.split(path.sep).join("/")
+        : value.split(path.sep).join("/");
+}
+function summary(values, limit = 3) {
+    if (values.length === 0)
+        return "workspace evidence";
+    return values.length <= limit
+        ? values.join(", ")
+        : `${values.slice(0, limit).join(", ")} +${values.length - limit} more`;
+}
+export function buildActions(root, activation, declared, candidates, signals) {
+    const result = [];
+    let order = 1;
+    const targets = [
+        ...new Set([
+            ...declared.sourceOfTruthPaths,
+            ...declared.priorityRoots,
+            ...signals.map((signal) => relative(root, signal.sourcePath)),
+        ]),
+    ];
+    result.push({
+        order: order++,
+        kind: "query",
+        description: targets.length > 0
+            ? `Review ${summary(targets)} before authoring or applying bootstrap output.`
+            : "Review workspace evidence and existing KB records before applying bootstrap output.",
+    });
+    if (activation.activationMode === "attached_thin_handoff" ||
+        activation.activationMode === "attached_seeded_handoff") {
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: "Use kb_search to explore existing KB entities and understand current coverage.",
+        });
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: "Use kb_query or kb_graph with task-relevant IDs to inspect cited KB context.",
+        });
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: activation.activationMode === "attached_thin_handoff"
+                ? "Use kb_find_gaps to identify coverage holes and guide incremental KB growth."
+                : "Use kb_coverage to review traceability and identify areas needing attention.",
+        });
+    }
+    if (activation.applyBlocked)
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: activation.handoffMessage ?? activation.reason,
+        });
+    else if (candidates.length > 0)
+        result.push({
+            order: order++,
+            kind: "upsert",
+            description: `Review and optionally upsert ${candidates.length} safe candidate(s) from deterministic evidence.`,
+            candidateIds: candidates.map((candidate) => candidate.candidateId),
+        });
+    if (signals.length > 0)
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: `Author ${[...new Set(signals.map((signal) => signal.kind.toUpperCase()))].join("/")} entities manually from source-only evidence.`,
+        });
+    result.push({
+        order,
+        kind: "check",
+        description: declared.verificationAnchors.length > 0
+            ? `After approved kb_upsert calls, run kb_check and verify ${summary(declared.verificationAnchors, 2)}.`
+            : "After approved kb_upsert calls, run kb_check to validate the resulting graph.",
+    });
+    return result;
+}

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

@@ -0,0 +1,14 @@
+import type { ActivationPolicy, AutopilotDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
+export declare function buildGuidance(input: {
+    readonly root: string;
+    readonly activation: ActivationPolicy;
+    readonly declared: AutopilotDeclaredContext;
+    readonly candidates: readonly Candidate[];
+    readonly signals: readonly SourceOnlySignal[];
+    readonly warnings: readonly string[];
+}): {
+    readonly promptBlock: string;
+    readonly confidence: Readonly<Record<string, unknown>>;
+    readonly actions: readonly Readonly<Record<string, unknown>>[];
+};
+//# sourceMappingURL=guidance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guidance.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/guidance.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAyJpB,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,GAAG;IACF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CAChE,CA0BA"}

package/dist/operations/autopilot/guidance.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import { buildActions } from "./guidance-actions.js";
+function relative(root, target) {
+    const value = path.relative(root, target);
+    return value.startsWith("..") || path.isAbsolute(value)
+        ? target.split(path.sep).join("/")
+        : value.split(path.sep).join("/");
+}
+function summary(values, limit = 3) {
+    if (values.length === 0)
+        return "workspace evidence";
+    return values.length <= limit
+        ? values.join(", ")
+        : `${values.slice(0, limit).join(", ")} +${values.length - limit} more`;
+}
+function counts(candidates) {
+    const result = {};
+    for (const candidate of candidates)
+        result[candidate.entityType] = (result[candidate.entityType] ?? 0) + 1;
+    return result;
+}
+function prompt(root, activation, declared, candidates, signals, warnings) {
+    const bullets = [];
+    bullets.push(activation.applyBlocked
+        ? `- Apply blocked: ${activation.reason}`
+        : `- Mode: ${activation.activationMode} (${activation.activationState}).`);
+    if (declared.projectSummary)
+        bullets.push(`- Summary: ${declared.projectSummary}`);
+    if (declared.sourceOfTruthPaths.length > 0)
+        bullets.push(`- Source of truth: ${summary(declared.sourceOfTruthPaths)}.`);
+    if (candidates.length > 0) {
+        const formatted = Object.entries(counts(candidates))
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([type, count]) => `${type} ${count}`)
+            .join(", ");
+        bullets.push(`- Safe candidates: ${candidates.length} (${formatted}).`);
+    }
+    if (signals.length > 0) {
+        const kinds = [
+            ...new Set(signals.map((signal) => signal.kind.toUpperCase())),
+        ].join("/");
+        const paths = [
+            ...new Set(signals.map((signal) => relative(root, signal.sourcePath))),
+        ];
+        bullets.push(`- Author ${kinds} manually from ${summary(paths)}; keep them out of speculative candidate output.`);
+    }
+    else if (declared.verificationAnchors.length > 0)
+        bullets.push(`- Verify after kb_check with ${summary(declared.verificationAnchors, 2)}.`);
+    if (activation.activationMode === "attached_thin_handoff" ||
+        activation.activationMode === "attached_seeded_handoff")
+        bullets.push("- Handoff: use kb_search, kb_query, or gap/coverage tools to work with existing KB.");
+    if (warnings.length > 0)
+        bullets.push(`- Scan diagnostics: ${warnings.length} warning(s) during evidence collection.`);
+    const words = bullets.slice(0, 5).join("\n").split(/\s+/).filter(Boolean);
+    const selected = words.slice(0, 120);
+    if (words.length > 120 && selected.length > 0)
+        selected[selected.length - 1] = `${selected[selected.length - 1]}…`;
+    return selected.join(" ").replaceAll(" - ", "\n- ");
+}
+function confidence(activation, declared, candidates, signals, promptBlock) {
+    const reasons = [];
+    let score = candidates.length > 0 ? 0.68 : 0.44;
+    if (activation.applyBlocked) {
+        score -= 0.24;
+        reasons.push("Current workspace posture blocks direct application.");
+    }
+    else {
+        score += 0.12;
+        reasons.push("Workspace posture allows read-only bootstrap synthesis.");
+    }
+    score += {
+        cold_start_bootstrap: 0.1,
+        repair_bootstrap: -0.05,
+        attached_thin_handoff: -0.12,
+        attached_seeded_handoff: -0.18,
+        vendored_blocked: -0.25,
+    }[activation.activationMode];
+    reasons.push(`${activation.activationMode} determined the bootstrap posture.`);
+    if (declared.projectSummary ||
+        declared.sourceOfTruthPaths.length +
+            declared.sourceOfTruthNotes.length +
+            declared.priorityRoots.length +
+            declared.verificationAnchors.length >
+            0) {
+        score += 0.08;
+        reasons.push("Declared bootstrap context grounds the output.");
+    }
+    else
+        reasons.push("No declared bootstrap context was supplied.");
+    if (signals.length > 0) {
+        score += 0.04;
+        reasons.push("Source-only evidence was routed into authoring guidance.");
+    }
+    if (candidates.length === 0) {
+        score -= 0.08;
+        reasons.push("No safe candidates were synthesized from current evidence.");
+    }
+    else
+        reasons.push(`${candidates.length} safe candidate(s) are ready for review.`);
+    if (!promptBlock) {
+        score -= 0.05;
+        reasons.push("Prompt block could not be assembled within the handoff budget.");
+    }
+    const rounded = Math.round(Math.max(0, Math.min(1, score)) * 100) / 100;
+    const level = rounded > 0.7 ? "high" : rounded >= 0.4 ? "medium" : "low";
+    const policy = level === "high"
+        ? "full_actions"
+        : level === "medium"
+            ? "review_required"
+            : "handoff_only";
+    if (level !== "high")
+        reasons.push(level === "medium"
+            ? "Medium confidence: review recommended before applying."
+            : "Low confidence: handoff-only output with diagnostic guidance.");
+    return { score: rounded, level, reasons, policy };
+}
+export function buildGuidance(input) {
+    const promptBlock = prompt(input.root, input.activation, input.declared, input.candidates, input.signals, input.warnings);
+    return {
+        promptBlock,
+        confidence: confidence(input.activation, input.declared, input.candidates, input.signals, promptBlock),
+        actions: buildActions(input.root, input.activation, input.declared, input.candidates, input.signals),
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { AutopilotEvidence, Candidate, SourceOnlySignal } from "./types.js";
+export type CandidateBuildResult = {
+    readonly candidates: readonly Candidate[];
+    readonly sourceOnlySignals: readonly SourceOnlySignal[];
+};
+export declare function markdownCandidates(item: AutopilotEvidence, existingIds: ReadonlySet<string>, minConfidence: number): CandidateBuildResult;
+//# sourceMappingURL=markdown-candidates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-candidates.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/markdown-candidates.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACzD,CAAC;AA0HF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,GACpB,oBAAoB,CAoDtB"}

package/dist/operations/autopilot/markdown-candidates.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { buildStrictWriteSet } from "../../utils/strict-modeling.js";
+import { confidenceBand, slug, strictPlan, upsert, } from "./candidate-helpers.js";
+import { claimFor } from "./requirement-claims.js";
+function headingSignals(heading, sourcePath, textRef, minConfidence) {
+    const result = [];
+    for (const [kind, pattern, confidence] of [
+        ["req", /\brequirements?\b/i, 0.84],
+        ["scenario", /\bscenarios?\b/i, 0.83],
+        ["test", /\b(tests?|verification)\b/i, 0.82],
+    ]) {
+        if (pattern.test(heading) && confidence >= minConfidence) {
+            result.push({
+                kind,
+                title: `Author ${kind} from ${heading}`,
+                sourcePath,
+                confidence,
+                evidence: [`generic_heading:${textRef}`],
+            });
+        }
+    }
+    return result;
+}
+function genericHeadingCandidate(item, heading, line, existingIds, minConfidence) {
+    const relativePath = item.relativePath ?? item.label;
+    const type = /\badr\b|architectur.*decision/i.test(heading)
+        ? "adr"
+        : /\b(observations?|facts?|notes?)\b/i.test(heading)
+            ? "fact"
+            : null;
+    const confidence = type === "adr" ? 0.9 : type === "fact" ? 0.8 : 0;
+    if (!type || confidence < minConfidence)
+        return null;
+    const id = `${type === "adr" ? "ADR" : "FACT"}-GEN-${slug(heading, 60) || slug(path.basename(relativePath))}`.toUpperCase();
+    if (existingIds.has(id))
+        return null;
+    const entity = {
+        type,
+        id,
+        title: heading,
+        status: type === "adr" ? "proposed" : "active",
+        ...(type === "fact" ? { fact_kind: "observation" } : {}),
+        source: `autopilot:generic:${relativePath}`,
+        text_ref: `${relativePath}#L${line}`,
+    };
+    return {
+        candidateId: `gen:${relativePath}:${type}:${slug(heading)}`,
+        entityType: type,
+        title: heading,
+        sourceKind: "generic_markdown",
+        sourcePath: item.absolutePath ?? relativePath,
+        confidence,
+        confidenceBand: confidenceBand(confidence),
+        evidence: [`generic_heading:${relativePath}#L${line}`],
+        relationships: [],
+        applyPlan: [upsert(entity)],
+    };
+}
+function requirementCandidate(item, statement, line, heading, headingLine, existingIds, minConfidence) {
+    const relativePath = item.relativePath ?? item.label;
+    const base = /\bshall\b/i.test(statement)
+        ? 0.86
+        : /\bmust\b/i.test(statement)
+            ? 0.84
+            : 0.78;
+    const confidence = Math.min(0.95, base +
+        (heading &&
+            /requirements?|constraints?|polic(?:y|ies)|rules?/i.test(heading)
+            ? 0.08
+            : 0));
+    if (confidence < minConfidence)
+        return null;
+    const claim = claimFor(statement, relativePath, confidence, `${relativePath}#L${line}`);
+    if (!claim)
+        return null;
+    const writeSet = buildStrictWriteSet({ claim, statement });
+    if (!writeSet.isStrict || existingIds.has(writeSet.req.id))
+        return null;
+    return {
+        candidateId: `norm:${writeSet.req.id.toLowerCase()}`,
+        entityType: "req",
+        title: statement,
+        sourceKind: "generic_markdown",
+        sourcePath: item.absolutePath ?? relativePath,
+        confidence,
+        confidenceBand: confidenceBand(confidence),
+        evidence: [
+            `normative_statement:${relativePath}#L${line}`,
+            ...(heading ? [`generic_heading:${relativePath}#L${headingLine}`] : []),
+        ],
+        relationships: writeSet.relationships.map(({ type, from, to }) => ({
+            type,
+            from,
+            to,
+        })),
+        applyPlan: strictPlan(writeSet),
+    };
+}
+export function markdownCandidates(item, existingIds, minConfidence) {
+    const candidates = [];
+    const sourceOnlySignals = [];
+    const relativePath = item.relativePath ?? item.label;
+    let heading;
+    let headingLine = 0;
+    let fenced = false;
+    for (const [index, line] of (item.content ?? "").split(/\r?\n/).entries()) {
+        if (/^\s*(```|~~~)/.test(line)) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced)
+            continue;
+        const match = line.match(/^\s*#+\s*(.+)$/);
+        if (match?.[1]) {
+            heading = match[1].trim();
+            headingLine = index + 1;
+            const candidate = genericHeadingCandidate(item, heading, headingLine, existingIds, minConfidence);
+            if (candidate)
+                candidates.push(candidate);
+            sourceOnlySignals.push(...headingSignals(heading, item.absolutePath ?? relativePath, `${relativePath}#L${headingLine}`, minConfidence));
+            continue;
+        }
+        const statement = line
+            .replace(/^\s*[-*+]\s+/, "")
+            .replace(/^\s*\d+[.)]\s+/, "")
+            .trim();
+        if (!statement || !/\b(must|shall|should)\b/i.test(statement))
+            continue;
+        const candidate = requirementCandidate(item, statement, index + 1, heading, headingLine, existingIds, minConfidence);
+        if (candidate)
+            candidates.push(candidate);
+    }
+    return { candidates, sourceOnlySignals };
+}

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

@@ -0,0 +1,13 @@
+import type { ActivationPolicy, AutopilotBootstrapContext, AutopilotDeclaredContext, AutopilotGenerateResult, Candidate, DiscoverySummary, SourceOnlySignal } from "./types.js";
+export declare function normalizeBootstrapContext(input?: AutopilotBootstrapContext): AutopilotDeclaredContext;
+export declare function presentAutopilot(input: {
+    readonly root: string;
+    readonly activation: ActivationPolicy;
+    readonly discoverySummary: DiscoverySummary;
+    readonly migrationWarning: string | null;
+    readonly bootstrapContext?: AutopilotBootstrapContext;
+    readonly candidates: readonly Candidate[];
+    readonly sourceOnlySignals: readonly SourceOnlySignal[];
+    readonly suppressedCandidates: readonly Readonly<Record<string, unknown>>[];
+}): AutopilotGenerateResult;
+//# sourceMappingURL=presentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presentation.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/presentation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB,wBAAgB,yBAAyB,CACvC,KAAK,CAAC,EAAE,yBAAyB,GAChC,wBAAwB,CAS1B;AAgBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,yBAAyB,CAAC;IACtD,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,oBAAoB,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CAC7E,GAAG,uBAAuB,CAoE1B"}