kibi-cli 0.19.0 → 1.0.1

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

@@ -30,12 +30,20 @@ function isScanGit(value) {
         "ignoredPaths" in value &&
         typeof value.ignoredPaths === "function");
 }
+const TYPED_KIBI_LANE = /(^|\/)(\.kb|documentation)\/(requirements|scenarios|tests|adr|flags|events|facts)\//;
+const EXECUTABLE_TEST_HARNESS = /(^|\/)(\.kb|documentation)\/tests\/(e2e|benchmarks)\//;
+function isTypedKibiMarkdownPath(relativePath) {
+    const posix = relativePath.replaceAll("\\", "/");
+    if (EXECUTABLE_TEST_HARNESS.test(posix))
+        return false;
+    return TYPED_KIBI_LANE.test(posix);
+}
 function classifyFile(relativePath, content) {
-    if (/symbols\.ya?ml$/i.test(relativePath))
+    if (/^\.kb\/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)
+            isTypedKibiMarkdownPath(relativePath)
             ? ["typed_kibi_docs", "typed_markdown"]
             : ["generic_repo_docs", "generic_markdown"];
     }
@@ -49,13 +57,35 @@ function classifyFile(relativePath, content) {
     return null;
 }
 function evidenceData(provider, relativePath, content) {
-    if (provider === "repo_metadata")
+    if (provider === "repo_metadata") {
+        const languages = new Set();
+        if (/^package\.json$/i.test(path.basename(relativePath))) {
+            try {
+                const parsed = JSON.parse(content);
+                const text = JSON.stringify(parsed);
+                if (/\.(?:ts|tsx|mts|cts)\b/.test(text))
+                    languages.add("typescript");
+                if (/\.(?:js|jsx|mjs|cjs)\b|node\b/.test(text))
+                    languages.add("javascript");
+            }
+            catch {
+                // The scanner records a parse warning separately below.
+            }
+        }
+        if (/Cargo\.toml$/i.test(relativePath))
+            languages.add("rust");
+        if (/go\.mod$/i.test(relativePath))
+            languages.add("go");
+        if (/pyproject\.toml$/i.test(relativePath))
+            languages.add("python");
         return {
             title: `Repository metadata: ${path.basename(relativePath)}`,
             factKind: "meta",
             confidence: relativePath.includes("tsconfig") ? 0.9 : 0.86,
             evidence: [`repo_metadata:${relativePath}`],
+            languages: [...languages],
         };
+    }
     if (provider === "test_topology") {
         const frameworks = [
             content.includes("bun:test") ? "bun:test" : "",
@@ -73,13 +103,17 @@ function evidenceData(provider, relativePath, content) {
             frameworks,
         };
     }
-    if (provider === "source_symbols")
+    if (provider === "source_symbols") {
+        const symbolCount = Array.from(content.matchAll(/\b(?:export\s+)?(?:function|class|const|let|var|interface|type)\s+([A-Za-z_$][\w$]*)/g)).length;
         return {
             title: `Source module: ${path.basename(relativePath, path.extname(relativePath))}`,
             factKind: "observation",
             confidence: 0.82,
             evidence: [`source_symbols:${relativePath}`],
+            analysisMode: "parser",
+            symbolCount,
         };
+    }
     return {};
 }
 function layoutEvidence(workspaceRoot, files, ignored) {
@@ -103,11 +137,12 @@ function layoutEvidence(workspaceRoot, files, ignored) {
         },
     }));
 }
+// implements REQ-KIBI-BOOTSTRAP-PLAN
 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.");
+        throw new OperationError("OPERATION_FAILED", "Bootstrap requires filesystem glob and git ignore ports.");
     const files = [
         ...(await fs.glob(SCAN_PATTERNS, {
             cwd: context.workspaceRoot,
@@ -150,7 +185,12 @@ export async function scanEvidence(context) {
             });
         }
         catch {
-            warnings.push(`failed_to_read:${relativePath}`);
+            const warningProvider = /\.(?:test|spec)\.[^.]+$/i.test(relativePath)
+                ? "test_topology"
+                : CODE_EXTENSION.test(relativePath)
+                    ? "source_symbols"
+                    : "generic_repo_docs";
+            warnings.push(`${warningProvider}:failed_to_${warningProvider === "test_topology" ? "read" : "analyze"}:${relativePath}`);
         }
     }
     evidence.push(...layoutEvidence(context.workspaceRoot, files, ignored));

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

@@ -1,4 +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>;
+export declare function discoverBootstrap(context: OperationContext): Promise<DiscoveryResult>;
 //# sourceMappingURL=discovery.d.ts.map

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

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

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

@@ -1,8 +1,8 @@
 import path from "node:path";
-import { getSchemaVersionStatus } from "../../public/schema-version.js";
+import { readKbManifestStatus } from "../../utils/kb-manifest.js";
 import { classifyActivation } from "./activation.js";
 import { scanEvidence } from "./discovery-evidence.js";
-import { AUTOPILOT_PROVIDER_ORDER, } from "./types.js";
+import { BOOTSTRAP_PROVIDER_ORDER, } from "./types.js";
 const EXCLUDED_ROOTS = [
     ".git",
     ".kb",
@@ -33,8 +33,10 @@ const LANGUAGE_NAMES = {
 };
 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;
+        const status = readKbManifestStatus(context.workspaceRoot);
+        if (status.state === "ok")
+            return null;
+        return status.warning;
     }
     catch {
         return null;
@@ -42,11 +44,15 @@ async function migrationWarning(context) {
 }
 function languages(evidence) {
     return [
-        ...new Set(evidence
-            .filter((item) => item.kind === "source_symbols")
-            .map((item) => {
+        ...new Set(evidence.flatMap((item) => {
             const extension = path.extname(item.label).slice(1);
-            return LANGUAGE_NAMES[extension] ?? extension;
+            const fromExtension = item.kind === "source_symbols"
+                ? [LANGUAGE_NAMES[extension] ?? extension]
+                : [];
+            const fromMetadata = Array.isArray(item.data.languages)
+                ? item.data.languages.filter((value) => typeof value === "string")
+                : [];
+            return [...fromExtension, ...fromMetadata];
         })),
     ].sort();
 }
@@ -57,21 +63,22 @@ function frameworks(evidence) {
             : [])),
     ].sort();
 }
-// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
-export async function discoverAutopilot(context) {
+// implements REQ-mcp-kibi-bootstrap-bootstrap-v1, REQ-kibi-operation-interface-parity
+// implements REQ-KIBI-BOOTSTRAP-PLAN
+export async function discoverBootstrap(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) ||
+    evidence.sort((left, right) => BOOTSTRAP_PROVIDER_ORDER.indexOf(left.provider) -
+        BOOTSTRAP_PROVIDER_ORDER.indexOf(right.provider) ||
         left.label.localeCompare(right.label));
     const providersRun = activation.allowCandidateGeneration
-        ? [...AUTOPILOT_PROVIDER_ORDER]
+        ? [...BOOTSTRAP_PROVIDER_ORDER]
         : [];
-    const providerCounts = Object.fromEntries(AUTOPILOT_PROVIDER_ORDER.map((provider) => [
+    const providerCounts = Object.fromEntries(BOOTSTRAP_PROVIDER_ORDER.map((provider) => [
         provider,
         evidence.filter((item) => item.provider === provider).length,
     ]));

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

@@ -0,0 +1,8 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { Candidate, PlanBootstrapArgs, PlanBootstrapResult } from "./types.js";
+export declare function selectBootstrapCandidates(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 executePlanBootstrap(args: PlanBootstrapArgs, context: OperationContext): Promise<PlanBootstrapResult>;
+//# sourceMappingURL=generate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/generate.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAKjF,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AA2BpB,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;AAkHD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CA2D9B"}

package/dist/operations/bootstrap/generate.js

@@ -0,0 +1,204 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+import { executeStatus } from "../../public/operations/discovery-executors.js";
+import { readWorkspaceSnapshot } from "../../public/operations/workspace-snapshot.js";
+import { buildBootstrapCandidates } from "./candidates.js";
+import { discoverBootstrap } from "./discovery.js";
+import { presentBootstrap } from "./presentation.js";
+import { bootstrapEmptyKbSnapshotId } from "./types.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
+        : "";
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function selectBootstrapCandidates(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();
+    }
+}
+async function expectedSnapshots(context, evidencePaths) {
+    const diagnostics = [];
+    try {
+        const result = await executeStatus({}, context);
+        const status = result.structuredContent;
+        const workspace = await readWorkspaceSnapshot(context);
+        const sourceHashes = {};
+        if (!context.fs) {
+            diagnostics.push("Bootstrap plan binding requires a filesystem-capable runtime.");
+        }
+        else {
+            // Bind every evidence document that can affect candidate selection. The
+            // workspace hash is still authoritative for the complete checkout, but
+            // these per-source hashes make the plan's evidence set inspectable.
+            // Layout providers legitimately surface directory rows (for example a
+            // bare `src` entry); directories carry no hashable document content and
+            // must not surface as binding diagnostics, which would otherwise block
+            // an otherwise-ready thin-bootstrap plan.
+            for (const relative of new Set(evidencePaths)) {
+                try {
+                    const resolved = path.resolve(context.workspaceRoot, relative);
+                    if (!(await context.fs.stat(resolved)).isFile())
+                        continue;
+                    sourceHashes[relative] = sha256(await context.fs.readFile(resolved));
+                }
+                catch {
+                    sourceHashes[relative] = null;
+                    diagnostics.push(`Bootstrap evidence source is unavailable: ${relative}`);
+                }
+            }
+        }
+        const branch = status?.branch ?? context.branchAttachment?.kbBranch;
+        const workspaceSnapshot = workspace.available
+            ? workspace.snapshot.hash
+            : undefined;
+        if (!branch || branch === "unknown")
+            diagnostics.push("Bootstrap plan binding could not determine the active Git branch.");
+        if (!workspaceSnapshot || !/^[a-f0-9]{64}$/i.test(workspaceSnapshot))
+            diagnostics.push("Bootstrap plan binding could not determine a current workspace snapshot.");
+        const rawSnapshot = status?.snapshotId;
+        const kbSnapshotId = rawSnapshot === "missing" &&
+            branch &&
+            workspaceSnapshot &&
+            /^[a-f0-9]{64}$/i.test(workspaceSnapshot)
+            ? bootstrapEmptyKbSnapshotId({
+                branch,
+                workspaceSnapshot,
+                sourceHashes,
+            })
+            : rawSnapshot;
+        if (!kbSnapshotId ||
+            kbSnapshotId === "unknown" ||
+            kbSnapshotId === "missing" ||
+            kbSnapshotId === "unavailable")
+            diagnostics.push("Bootstrap plan binding could not determine a current KB snapshot.");
+        return {
+            branch: branch ?? "unavailable",
+            kbSnapshotId: kbSnapshotId ?? "unavailable",
+            workspaceSnapshot: workspaceSnapshot ?? "unavailable",
+            sourceHashes,
+            bindingDiagnostics: diagnostics,
+        };
+    }
+    catch {
+        return {
+            branch: context.branchAttachment?.kbBranch ?? "unavailable",
+            kbSnapshotId: "unavailable",
+            workspaceSnapshot: "unavailable",
+            sourceHashes: {},
+            bindingDiagnostics: [
+                "Bootstrap plan binding could not read current repository state.",
+            ],
+        };
+    }
+}
+// implements REQ-mcp-kibi-bootstrap-bootstrap-v1, REQ-kibi-operation-interface-parity
+// implements REQ-KIBI-BOOTSTRAP-PLAN
+export async function executePlanBootstrap(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([
+        discoverBootstrap(context),
+        existingEntityIds(context),
+    ]);
+    // Discovery runs before planning so its evidence paths can be bound into
+    // the exact plan rather than leaving the reviewer to reconstruct them.
+    const bound = await expectedSnapshots(context, discovery.evidence
+        .map((evidence) => evidence.relativePath)
+        .filter((value) => Boolean(value)));
+    const built = discovery.activation.allowCandidateGeneration
+        ? buildBootstrapCandidates(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 = selectBootstrapCandidates(built.candidates.filter((candidate) => candidate.confidence >= minConfidence), existingIds, args.entityTypes, maxCandidates);
+    const ignored = discovery.ignoredSources.map((sourcePath) => ({
+        candidateId: "",
+        reason: "ignored_source",
+        sourcePath,
+        entityType: "",
+    }));
+    const { bindingDiagnostics, ...expected } = bound;
+    return presentBootstrap({
+        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],
+        expected,
+        bindingDiagnostics,
+    });
+}

package/dist/operations/{autopilot → bootstrap}/guidance-actions.d.ts

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

package/dist/operations/{autopilot → bootstrap}/guidance-actions.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"guidance-actions.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/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 → bootstrap}/guidance-actions.js

@@ -58,8 +58,8 @@ export function buildActions(root, activation, declared, candidates, signals) {
     else if (candidates.length > 0)
         result.push({
             order: order++,
-            kind: "upsert",
-            description: `Review and optionally upsert ${candidates.length} safe candidate(s) from deterministic evidence.`,
+            kind: "plan",
+            description: `Review the ${candidates.length} safe candidate(s) in the hash-bound plan, then call kb_apply_plan after explicit approval.`,
             candidateIds: candidates.map((candidate) => candidate.candidateId),
         });
     if (signals.length > 0)
@@ -72,8 +72,8 @@ export function buildActions(root, activation, declared, candidates, signals) {
         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.",
+            ? `After kb_apply_plan, run kb_check and verify ${summary(declared.verificationAnchors, 2)}.`
+            : "After kb_apply_plan, run kb_check to validate the resulting graph.",
     });
     return result;
 }

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

@@ -1,8 +1,8 @@
-import type { ActivationPolicy, AutopilotDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
+import type { ActivationPolicy, BootstrapDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
 export declare function buildGuidance(input: {
     readonly root: string;
     readonly activation: ActivationPolicy;
-    readonly declared: AutopilotDeclaredContext;
+    readonly declared: BootstrapDeclaredContext;
     readonly candidates: readonly Candidate[];
     readonly signals: readonly SourceOnlySignal[];
     readonly warnings: readonly string[];

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

@@ -1 +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"}
+{"version":3,"file":"guidance.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/guidance.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AA2JpB,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 → bootstrap}/guidance.js

@@ -71,6 +71,7 @@ function confidence(activation, declared, candidates, signals, promptBlock) {
     score += {
         cold_start_bootstrap: 0.1,
         repair_bootstrap: -0.05,
+        attached_thin_bootstrap: 0.04,
         attached_thin_handoff: -0.12,
         attached_seeded_handoff: -0.18,
         vendored_blocked: -0.25,
@@ -114,6 +115,7 @@ function confidence(activation, declared, candidates, signals, promptBlock) {
             : "Low confidence: handoff-only output with diagnostic guidance.");
     return { score: rounded, level, reasons, policy };
 }
+// implements REQ-KIBI-BOOTSTRAP-PLAN
 export function buildGuidance(input) {
     const promptBlock = prompt(input.root, input.activation, input.declared, input.candidates, input.signals, input.warnings);
     return {

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

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

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

@@ -1 +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"}
+{"version":3,"file":"markdown-candidates.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/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;AA4HF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,GACpB,oBAAoB,CAoDtB"}

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

@@ -12,7 +12,7 @@ function headingSignals(heading, sourcePath, textRef, minConfidence) {
         if (pattern.test(heading) && confidence >= minConfidence) {
             result.push({
                 kind,
-                title: `Author ${kind} from ${heading}`,
+                title: `Author ${kind === "req" ? "requirements" : `${kind}s`} from ${heading}`,
                 sourcePath,
                 confidence,
                 evidence: [`generic_heading:${textRef}`],
@@ -40,7 +40,7 @@ function genericHeadingCandidate(item, heading, line, existingIds, minConfidence
         title: heading,
         status: type === "adr" ? "proposed" : "active",
         ...(type === "fact" ? { fact_kind: "observation" } : {}),
-        source: `autopilot:generic:${relativePath}`,
+        source: `bootstrap:generic:${relativePath}`,
         text_ref: `${relativePath}#L${line}`,
     };
     return {
@@ -50,7 +50,7 @@ function genericHeadingCandidate(item, heading, line, existingIds, minConfidence
         sourceKind: "generic_markdown",
         sourcePath: item.absolutePath ?? relativePath,
         confidence,
-        confidenceBand: confidenceBand(confidence),
+        confidenceBand: confidence >= 0.95 ? "high" : confidence >= 0.8 ? "medium" : "low",
         evidence: [`generic_heading:${relativePath}#L${line}`],
         relationships: [],
         applyPlan: [upsert(entity)],
@@ -96,6 +96,7 @@ function requirementCandidate(item, statement, line, heading, headingLine, exist
         applyPlan: strictPlan(writeSet),
     };
 }
+// implements REQ-KIBI-BOOTSTRAP-PLAN
 export function markdownCandidates(item, existingIds, minConfidence) {
     const candidates = [];
     const sourceOnlySignals = [];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"presentation.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/presentation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAEhB,gBAAgB,EAChB,wBAAwB,EACxB,eAAe,EACf,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAUpB,wBAAgB,yBAAyB,CACvC,KAAK,CAAC,EAAE,gBAAgB,GACvB,wBAAwB,CAS1B;AAiBD,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,gBAAgB,CAAC;IAC7C,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;IAC5E,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;IAC/C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjD,GAAG,mBAAmB,CA0KtB"}