kibi-cli 0.14.0 → 0.17.0

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"}

package/dist/operations/autopilot/presentation.js

@@ -0,0 +1,91 @@
+import { buildGuidance } from "./guidance.js";
+function strings(values) {
+    return [
+        ...new Set((values ?? []).map((value) => value.trim()).filter(Boolean)),
+    ];
+}
+export function normalizeBootstrapContext(input) {
+    const projectSummary = input?.projectSummary?.trim();
+    return {
+        ...(projectSummary ? { projectSummary } : {}),
+        sourceOfTruthPaths: strings(input?.sourceOfTruthPaths),
+        sourceOfTruthNotes: strings(input?.sourceOfTruthNotes),
+        priorityRoots: strings(input?.priorityRoots),
+        verificationAnchors: strings(input?.verificationAnchors),
+    };
+}
+function payoff(candidates) {
+    const projectedIfAllApplied = {};
+    for (const candidate of candidates)
+        projectedIfAllApplied[candidate.entityType] =
+            (projectedIfAllApplied[candidate.entityType] ?? 0) + 1;
+    return {
+        current: {},
+        projectedIfAllApplied,
+        delta: { ...projectedIfAllApplied },
+    };
+}
+export function presentAutopilot(input) {
+    const declaredContext = normalizeBootstrapContext(input.bootstrapContext);
+    const guidance = buildGuidance({
+        root: input.root,
+        activation: input.activation,
+        declared: declaredContext,
+        candidates: input.candidates,
+        signals: input.sourceOnlySignals,
+        warnings: input.discoverySummary.scanWarnings,
+    });
+    const confidenceLevel = String(guidance.confidence.level);
+    const applyBlocked = input.activation.applyBlocked ||
+        confidenceLevel === "medium" ||
+        confidenceLevel === "low";
+    const blockedFallback = input.activation.activationMode === "vendored_blocked"
+        ? `Autopilot bootstrap blocked: ${input.activation.reason}`
+        : input.activation.activationMode === "attached_thin_handoff" ||
+            input.activation.activationMode === "attached_seeded_handoff"
+            ? `Autopilot handoff: ${input.activation.reason}`
+            : "Bootstrap output found no safe candidates; follow the recommended actions to continue.";
+    const baseTldr = input.candidates.length + input.sourceOnlySignals.length > 0
+        ? `Bootstrap output is ready with ${input.candidates.length} safe candidate(s) and ${input.sourceOnlySignals.length} source-only authoring follow-up(s).`
+        : (input.activation.handoffMessage ?? blockedFallback);
+    const tldr = confidenceLevel === "low" && !input.activation.applyBlocked
+        ? `Low-confidence bootstrap (${String(guidance.confidence.score)}): review diagnostics before proceeding. ${baseTldr}`
+        : baseTldr;
+    const applyPlan = input.candidates.flatMap((candidate) => [
+        ...candidate.applyPlan,
+    ]);
+    const payoffSummary = payoff(input.candidates);
+    const structuredContent = {
+        activationState: input.activation.activationState,
+        activationMode: input.activation.activationMode,
+        bootstrapMode: input.activation.activationMode,
+        activationReason: input.activation.reason,
+        applyBlocked,
+        migrationWarning: input.migrationWarning,
+        ...(input.activation.handoffMessage
+            ? { handoffMessage: input.activation.handoffMessage }
+            : {}),
+        confidence: guidance.confidence,
+        tldr,
+        promptBlock: guidance.promptBlock,
+        recommendedActions: guidance.actions,
+        declaredContext,
+        discoverySummary: input.discoverySummary,
+        candidates: input.candidates,
+        applyPlan,
+        suppressedCandidates: input.suppressedCandidates,
+        payoffSummary,
+    };
+    const text = applyPlan.length > 0
+        ? `${tldr} Review structuredContent.applyPlan for exact sequential kb_upsert payloads before requesting approval.`
+        : tldr;
+    return {
+        content: [{ type: "text", text }],
+        structuredContent,
+        migrationWarning: input.migrationWarning,
+        candidates: input.candidates,
+        applyPlan,
+        suppressedCandidates: input.suppressedCandidates,
+        payoffSummary,
+    };
+}

package/dist/operations/autopilot/requirement-claims.d.ts

@@ -0,0 +1,3 @@
+import type { SemanticClaim } from "../../utils/strict-modeling.js";
+export declare function claimFor(statement: string, source: string, confidence: number, provenance: string): SemanticClaim | null;
+//# sourceMappingURL=requirement-claims.d.ts.map

package/dist/operations/autopilot/requirement-claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-claims.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/requirement-claims.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE,wBAAgB,QAAQ,CACtB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,aAAa,GAAG,IAAI,CAsDtB"}

package/dist/operations/autopilot/requirement-claims.js

@@ -0,0 +1,48 @@
+export function claimFor(statement, source, confidence, provenance) {
+    const normalized = statement.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim();
+    const retention = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+retained\s+for\s+(?<value>\d+)\s+(?<unit>day|days|month|months|year|years)\.?$/i);
+    if (retention?.groups?.subject &&
+        retention.groups.value &&
+        retention.groups.unit) {
+        const unit = retention.groups.unit.toLowerCase().startsWith("day")
+            ? "Days"
+            : retention.groups.unit.toLowerCase().startsWith("month")
+                ? "Months"
+                : "Years";
+        return {
+            source,
+            subjectKey: retention.groups.subject
+                .replace(/^(the|a|an)\s+/i, "")
+                .trim(),
+            propertyKey: `Retention ${unit}`,
+            operator: "eq",
+            value: Number(retention.groups.value),
+            confidence,
+            provenance,
+        };
+    }
+    const state = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<value>enabled|disabled)\.?$/i);
+    if (state?.groups?.subject && state.groups.value) {
+        return {
+            source,
+            subjectKey: state.groups.subject.trim(),
+            propertyKey: "enabled",
+            operator: "bool",
+            value: state.groups.value.toLowerCase() === "enabled",
+            confidence,
+            provenance,
+        };
+    }
+    const polarity = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+(?<negative>not\s+)?(?<predicate>.+?)\.?$/i);
+    if (!polarity?.groups?.subject || !polarity.groups.predicate)
+        return null;
+    return {
+        source,
+        subjectKey: polarity.groups.subject.trim(),
+        propertyKey: polarity.groups.predicate.trim(),
+        operator: "polarity",
+        value: polarity.groups.negative ? "forbid" : "require",
+        confidence,
+        provenance,
+    };
+}