kibi-cli 2.3.0 → 2.5.0

package/dist/operations/bootstrap/candidates.js

@@ -4,42 +4,37 @@ import { extractFromMarkdownString } from "../../extractors/markdown.js";
 import { confidenceBand, slug, upsert } from "./candidate-helpers.js";
 import { markdownCandidates, } from "./markdown-candidates.js";
 function typedCandidates(item, existingIds) {
-    try {
-        const results = item.kind === "symbol_manifest"
-            ? extractFromManifestString(item.content ?? "", item.relativePath ?? item.label)
-            : [
-                extractFromMarkdownString(item.content ?? "", item.relativePath ?? item.label),
-            ];
-        return results.flatMap(({ entity, relationships }) => {
-            if (existingIds.has(entity.id))
-                return [];
-            const sourceKind = item.kind === "symbol_manifest" ? "symbol_manifest" : "typed_markdown";
-            return [
-                {
-                    candidateId: `${sourceKind === "symbol_manifest" ? "mf" : "md"}:${item.relativePath}:${entity.id}`,
-                    entityType: entity.type,
-                    title: entity.title,
-                    sourceKind,
-                    sourcePath: item.absolutePath ?? item.label,
-                    confidence: sourceKind === "symbol_manifest" ? 0.98 : 1,
-                    confidenceBand: "high",
-                    evidence: [
-                        `extracted_from_${sourceKind}:${item.relativePath}`,
-                        `entity_id:${entity.id}`,
-                    ],
-                    relationships: relationships.map(({ type, from, to }) => ({
-                        type,
-                        from,
-                        to,
-                    })),
-                    applyPlan: [upsert(entity, relationships)],
-                },
-            ];
-        });
-    }
-    catch {
-        return [];
-    }
+    const results = item.kind === "symbol_manifest"
+        ? extractFromManifestString(item.content ?? "", item.relativePath ?? item.label)
+        : [
+            extractFromMarkdownString(item.content ?? "", item.relativePath ?? item.label),
+        ];
+    return results.flatMap(({ entity, relationships }) => {
+        if (existingIds.has(entity.id))
+            return [];
+        const sourceKind = item.kind === "symbol_manifest" ? "symbol_manifest" : "typed_markdown";
+        return [
+            {
+                candidateId: `${sourceKind === "symbol_manifest" ? "mf" : "md"}:${item.relativePath}:${entity.id}`,
+                entityType: entity.type,
+                title: entity.title,
+                sourceKind,
+                sourcePath: item.absolutePath ?? item.label,
+                confidence: sourceKind === "symbol_manifest" ? 0.98 : 1,
+                confidenceBand: "high",
+                evidence: [
+                    `extracted_from_${sourceKind}:${item.relativePath}`,
+                    `entity_id:${entity.id}`,
+                ],
+                relationships: relationships.map(({ type, from, to }) => ({
+                    type,
+                    from,
+                    to,
+                })),
+                applyPlan: [upsert(entity, relationships)],
+            },
+        ];
+    });
 }
 function providerCandidate(item, existingIds, minConfidence) {
     if (!new Set([
@@ -91,18 +86,37 @@ function providerCandidate(item, existingIds, minConfidence) {
         },
     ];
 }
-// implements REQ-mcp-kibi-bootstrap-bootstrap-v1, REQ-kibi-operation-interface-parity
+// implements REQ-KIBI-BOOTSTRAP-PLAN, REQ-kibi-operation-interface-parity
 // implements REQ-KIBI-BOOTSTRAP-PLAN
 export function buildBootstrapCandidates(evidence, existingIds, minConfidence, includeGenericMarkdown) {
     const candidates = [];
     const sourceOnlySignals = [];
+    const diagnostics = [];
+    const suppressed = [];
     for (const item of evidence) {
-        if (item.kind === "typed_markdown" || item.kind === "symbol_manifest")
-            candidates.push(...typedCandidates(item, existingIds));
+        if (item.kind === "typed_markdown" || item.kind === "symbol_manifest") {
+            try {
+                candidates.push(...typedCandidates(item, existingIds));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const sourcePath = item.relativePath ?? item.label;
+                diagnostics.push(`Bootstrap extraction failed at ${sourcePath}: ${message}`);
+                suppressed.push({
+                    candidateId: "",
+                    sourcePath,
+                    entityType: "",
+                    reason: "extraction_failed",
+                    message,
+                });
+            }
+        }
         if (item.kind === "generic_markdown" && includeGenericMarkdown) {
             const built = markdownCandidates(item, existingIds, minConfidence);
             candidates.push(...built.candidates);
             sourceOnlySignals.push(...built.sourceOnlySignals);
+            diagnostics.push(...built.diagnostics);
+            suppressed.push(...built.suppressed);
         }
         if (item.kind === "test_topology") {
             const confidence = typeof item.data.confidence === "number" ? item.data.confidence : 0.8;
@@ -122,6 +136,8 @@ export function buildBootstrapCandidates(evidence, existingIds, minConfidence, i
     }
     return {
         candidates,
+        diagnostics,
+        suppressed,
         sourceOnlySignals: sourceOnlySignals.sort((left, right) => right.confidence - left.confidence ||
             left.sourcePath.localeCompare(right.sourcePath)),
     };

package/dist/operations/bootstrap/discovery.js

@@ -63,7 +63,7 @@ function frameworks(evidence) {
             : [])),
     ].sort();
 }
-// implements REQ-mcp-kibi-bootstrap-bootstrap-v1, REQ-kibi-operation-interface-parity
+// implements REQ-KIBI-BOOTSTRAP-PLAN, REQ-kibi-operation-interface-parity
 // implements REQ-KIBI-BOOTSTRAP-PLAN
 export async function discoverBootstrap(context) {
     const scan = await scanEvidence(context);

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

@@ -4,6 +4,8 @@ export declare function filterSourceOnlySignals(signals: readonly SourceOnlySign
 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>>[];
+    readonly sourceOnlySignals: readonly SourceOnlySignal[];
+    readonly diagnostics: readonly string[];
 };
 export declare function executePlanBootstrap(args: PlanBootstrapArgs, context: OperationContext): Promise<PlanBootstrapResult>;
 //# sourceMappingURL=generate.d.ts.map

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

@@ -1 +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,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACzC,SAAS,gBAAgB,EAAE,CAI7B;AA2BD,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;AA+GD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAyD9B"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/generate.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAOjF,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACzC,SAAS,gBAAgB,EAAE,CAI7B;AA8BD,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;IAClE,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAsFA;AAiHD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CA6F9B"}

package/dist/operations/bootstrap/generate.js

@@ -5,7 +5,9 @@ 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 { buildIntentClaimCandidates } from "./intent-claims.js";
+import { normalizeBootstrapContext, presentBootstrap } from "./presentation.js";
+import { validateBootstrapPayload } from "./validation.js";
 export function filterSourceOnlySignals(signals, entityTypes) {
     return entityTypes && entityTypes.length > 0
         ? signals.filter((signal) => entityTypes.includes(signal.kind))
@@ -19,7 +21,7 @@ function titleKey(candidate) {
     return `${candidate.entityType}::${candidate.title.trim().toLowerCase().replace(/\s+/g, " ")}`;
 }
 function firstUpsertId(candidate) {
-    const first = candidate.applyPlan[0];
+    const first = candidate.applyPlan.find((payload) => payload.type === candidate.entityType) ?? candidate.applyPlan[0];
     if (typeof first?.id === "string")
         return first.id;
     const properties = first?.properties;
@@ -34,48 +36,84 @@ 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 allowed = entityTypes?.length ? new Set(entityTypes) : null;
+    const lane = (candidate) => {
+        if (candidate.sourceKind === "intent_claim")
+            return 0;
+        if (candidate.entityType === "req" &&
+            ["typed_markdown", "generic_markdown"].includes(candidate.sourceKind))
+            return 1;
+        return 2;
+    };
     const suppressed = [];
-    const suppress = (candidate, reason) => {
+    const sourceOnlySignals = [];
+    const diagnostics = [];
+    const suppress = (candidate, reason, message) => {
         suppressed.push({
             candidateId: candidate.candidateId,
             reason,
             sourcePath: candidate.sourcePath,
             entityType: candidate.entityType,
+            ...(message ? { message } : {}),
         });
     };
-    for (const candidate of sorted) {
+    const writable = input
+        .filter((candidate) => {
+        if (allowed && !allowed.has(candidate.entityType))
+            return false;
         if (existingIds.has(firstUpsertId(candidate))) {
             suppress(candidate, "entity_exists");
-            continue;
+            return false;
+        }
+        try {
+            if (candidate.applyPlan.length === 0)
+                throw new Error("Candidate has no write actions");
+            for (const payload of candidate.applyPlan)
+                validateBootstrapPayload(payload, new Date());
+            return true;
         }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            suppress(candidate, "invalid_write", message);
+            diagnostics.push(`Invalid bootstrap candidate at ${candidate.sourcePath}: ${message}`);
+            sourceOnlySignals.push({
+                kind: "req",
+                title: `Author requirement: ${candidate.title}`,
+                sourcePath: candidate.sourcePath,
+                confidence: candidate.confidence,
+                evidence: candidate.evidence,
+            });
+            return false;
+        }
+    })
+        .sort((left, right) => lane(left) - lane(right) ||
+        right.confidence - left.confidence ||
+        left.sourcePath.localeCompare(right.sourcePath) ||
+        left.candidateId.localeCompare(right.candidateId));
+    const typedTitles = new Set(writable
+        .filter((candidate) => candidate.sourceKind === "typed_markdown")
+        .map(titleKey));
+    const selected = new Map();
+    for (const candidate of writable) {
         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;
+        else if (selected.has(key)) {
+            suppress(candidate, "duplicate_title");
         }
-        const keepCandidate = candidate.confidence > previous.confidence ||
-            (candidate.confidence === previous.confidence &&
-                candidate.sourcePath < previous.sourcePath);
-        suppress(keepCandidate ? previous : candidate, "duplicate_title");
-        if (keepCandidate)
+        else
             selected.set(key, candidate);
     }
-    return { candidates: [...selected.values()], suppressed };
+    const unique = [...selected.values()];
+    for (const candidate of unique.slice(maximum))
+        suppress(candidate, "over_limit");
+    return {
+        candidates: unique.slice(0, maximum),
+        suppressed,
+        sourceOnlySignals,
+        diagnostics,
+    };
 }
 async function existingEntityIds(context) {
     if (!context.prolog)
@@ -85,8 +123,8 @@ async function existingEntityIds(context) {
         // just to build this set exceeds the bounded engine output.
         return new Set((await loadEntityIds(context.prolog)).filter(Boolean));
     }
-    catch {
-        return new Set();
+    catch (error) {
+        throw new Error(`Bootstrap binding could not read existing entity IDs: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 async function expectedSnapshots(context, evidencePaths) {
@@ -164,15 +202,19 @@ async function expectedSnapshots(context, evidencePaths) {
         };
     }
 }
-// implements REQ-mcp-kibi-bootstrap-bootstrap-v1, REQ-kibi-operation-interface-parity
+// implements REQ-KIBI-BOOTSTRAP-PLAN, 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 entityBindingDiagnostics = [];
     const [discovery, existingIds] = await Promise.all([
         discoverBootstrap(context),
-        existingEntityIds(context),
+        existingEntityIds(context).catch((error) => {
+            entityBindingDiagnostics.push(error.message);
+            return new Set();
+        }),
     ]);
     // Discovery runs before planning so its evidence paths can be bound into
     // the exact plan rather than leaving the reviewer to reconstruct them.
@@ -180,10 +222,25 @@ export async function executePlanBootstrap(args, context) {
         .map((evidence) => evidence.relativePath)
         .filter((value) => Boolean(value)));
     const built = discovery.activation.allowCandidateGeneration
-        ? buildBootstrapCandidates(discovery.evidence, existingIds, minConfidence, includeGenericMarkdown)
-        : { candidates: [], sourceOnlySignals: [] };
-    const filteredSignals = filterSourceOnlySignals(built.sourceOnlySignals, args.entityTypes);
-    const selected = selectBootstrapCandidates(built.candidates.filter((candidate) => candidate.confidence >= minConfidence), existingIds, args.entityTypes, maxCandidates);
+        ? buildBootstrapCandidates(discovery.evidence, new Set(), minConfidence, includeGenericMarkdown)
+        : {
+            candidates: [],
+            sourceOnlySignals: [],
+            suppressed: [],
+            diagnostics: [],
+        };
+    // Intent harvested from declared knowledge sources joins the repository
+    // evidence under the same activation policy, filters, and selection.
+    const claimed = discovery.activation.allowCandidateGeneration
+        ? buildIntentClaimCandidates(normalizeBootstrapContext(args.bootstrapContext), existingIds, minConfidence)
+        : {
+            candidates: [],
+            sourceOnlySignals: [],
+            suppressed: [],
+            diagnostics: [],
+        };
+    const filteredSignals = filterSourceOnlySignals([...built.sourceOnlySignals, ...claimed.sourceOnlySignals], args.entityTypes);
+    const selected = selectBootstrapCandidates([...built.candidates, ...claimed.candidates].filter((candidate) => candidate.confidence >= minConfidence), existingIds, args.entityTypes, maxCandidates);
     const ignored = discovery.ignoredSources.map((sourcePath) => ({
         candidateId: "",
         reason: "ignored_source",
@@ -200,9 +257,22 @@ export async function executePlanBootstrap(args, context) {
             ? { bootstrapContext: args.bootstrapContext }
             : {}),
         candidates: selected.candidates,
-        sourceOnlySignals: filteredSignals,
-        suppressedCandidates: [...selected.suppressed, ...ignored],
+        sourceOnlySignals: [
+            ...filteredSignals,
+            ...filterSourceOnlySignals(selected.sourceOnlySignals, args.entityTypes),
+        ],
+        suppressedCandidates: [
+            ...selected.suppressed,
+            ...claimed.suppressed,
+            ...built.suppressed,
+            ...ignored,
+        ],
         expected,
-        bindingDiagnostics,
+        bindingDiagnostics: [...bindingDiagnostics, ...entityBindingDiagnostics],
+        contextDiagnostics: [
+            ...claimed.diagnostics,
+            ...built.diagnostics,
+            ...selected.diagnostics,
+        ],
     });
 }

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

@@ -1 +1 @@
-{"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"}
+{"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;AAkBpB,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/bootstrap/guidance-actions.js

@@ -1,5 +1,8 @@
 import path from "node:path";
 function relative(root, target) {
+    // Intent claims cite tickets and URLs, which are not workspace paths.
+    if (!path.isAbsolute(target))
+        return target;
     const value = path.relative(root, target);
     return value.startsWith("..") || path.isAbsolute(value)
         ? target.split(path.sep).join("/")

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

@@ -1 +1 @@
-{"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;AAkFpB,wBAAgB,UAAU,CACxB,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,wBAAwB,EAClC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,WAAW,EAAE,MAAM,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAgEnC;AAGD,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;AAwFpB,wBAAgB,UAAU,CACxB,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,wBAAwB,EAClC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,WAAW,EAAE,MAAM,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAiEnC;AAGD,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/bootstrap/guidance.js

@@ -1,6 +1,9 @@
 import path from "node:path";
 import { buildActions } from "./guidance-actions.js";
 function relative(root, target) {
+    // Intent claims cite tickets and URLs, which are not workspace paths.
+    if (!path.isAbsolute(target))
+        return target;
     const value = path.relative(root, target);
     return value.startsWith("..") || path.isAbsolute(value)
         ? target.split(path.sep).join("/")
@@ -28,6 +31,8 @@ function prompt(root, activation, declared, candidates, signals, warnings) {
         bullets.push(`- Summary: ${declared.projectSummary}`);
     if (declared.sourceOfTruthPaths.length > 0)
         bullets.push(`- Source of truth: ${summary(declared.sourceOfTruthPaths)}.`);
+    if (declared.knowledgeSources)
+        bullets.push(`- Knowledge sources: ${summary(declared.knowledgeSources.map((source) => `${source.title} (${source.authority})`))}; ${declared.intentClaims?.length ?? 0} cited intent claim(s).`);
     if (candidates.length > 0) {
         const formatted = Object.entries(counts(candidates))
             .sort(([left], [right]) => left.localeCompare(right))
@@ -81,7 +86,8 @@ export function confidence(activation, declared, candidates, signals, promptBloc
         declared.sourceOfTruthPaths.length +
             declared.sourceOfTruthNotes.length +
             declared.priorityRoots.length +
-            declared.verificationAnchors.length >
+            declared.verificationAnchors.length +
+            (declared.knowledgeSources?.length ?? 0) >
             0) {
         score += 0.08;
         reasons.push("Declared bootstrap context grounds the output.");

package/dist/operations/bootstrap/intent-claims.d.ts

@@ -0,0 +1,17 @@
+import type { BootstrapDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
+export type IntentClaimBuildResult = {
+    readonly candidates: readonly Candidate[];
+    readonly sourceOnlySignals: readonly SourceOnlySignal[];
+    readonly suppressed: readonly Readonly<Record<string, unknown>>[];
+    readonly diagnostics: readonly string[];
+};
+/**
+ * Turn intent the agent harvested from declared knowledge sources into cited
+ * bootstrap candidates. Kibi never contacts those sources: it only records
+ * what the agent read, binds it into the plan hash through the declared
+ * context, and keeps the citation on every candidate it produces. A claim the
+ * strict modeler cannot ground stays an explicit authoring follow-up instead
+ * of becoming unverifiable knowledge.
+ */
+export declare function buildIntentClaimCandidates(declared: BootstrapDeclaredContext, existingIds: ReadonlySet<string>, minConfidence: number): IntentClaimBuildResult;
+//# sourceMappingURL=intent-claims.d.ts.map

package/dist/operations/bootstrap/intent-claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-claims.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/intent-claims.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,wBAAwB,EAGxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAClE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAAC;AAcF;;;;;;;GAOG;AAEH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,GACpB,sBAAsB,CA2FxB"}

package/dist/operations/bootstrap/intent-claims.js

@@ -0,0 +1,103 @@
+import { buildStrictWriteSet } from "../../utils/strict-modeling.js";
+import { confidenceBand, strictPlan } from "./candidate-helpers.js";
+import { claimFor } from "./requirement-claims.js";
+/** How much a claim is trusted follows the authority the human assigned. */
+const AUTHORITY_CONFIDENCE = {
+    authoritative: 0.9,
+    supporting: 0.82,
+};
+function citation(source, claim) {
+    return [
+        `intent_claim:${source.id}:${claim.reference}`,
+        `knowledge_source:${source.kind}:${source.locator}`,
+        `source_authority:${source.authority}`,
+        ...(source.connector ? [`connector:${source.connector}`] : []),
+    ];
+}
+/**
+ * Turn intent the agent harvested from declared knowledge sources into cited
+ * bootstrap candidates. Kibi never contacts those sources: it only records
+ * what the agent read, binds it into the plan hash through the declared
+ * context, and keeps the citation on every candidate it produces. A claim the
+ * strict modeler cannot ground stays an explicit authoring follow-up instead
+ * of becoming unverifiable knowledge.
+ */
+// implements REQ-kibi-bootstrap-knowledge-sources
+export function buildIntentClaimCandidates(declared, existingIds, minConfidence) {
+    const sources = new Map((declared.knowledgeSources ?? []).map((source) => [source.id, source]));
+    const candidates = [];
+    const sourceOnlySignals = [];
+    const suppressed = [];
+    const diagnostics = [];
+    for (const claim of declared.intentClaims ?? []) {
+        const source = sources.get(claim.sourceId);
+        if (!source) {
+            diagnostics.push(`Intent claim cites an undeclared knowledge source "${claim.sourceId}" (${claim.reference}); declare it in knowledgeSources or drop the claim.`);
+            continue;
+        }
+        if (source.authority === "stale") {
+            suppressed.push({
+                candidateId: "",
+                reason: "stale_knowledge_source",
+                sourcePath: claim.reference,
+                entityType: "req",
+                statement: claim.statement,
+                sourceId: source.id,
+            });
+            continue;
+        }
+        const confidence = AUTHORITY_CONFIDENCE[source.authority];
+        const evidence = citation(source, claim);
+        const provenance = `${source.id}:${claim.reference}`;
+        let writeSet = null;
+        try {
+            const modeled = claimFor(claim.statement, `knowledge-source:${source.id}`, confidence, provenance);
+            writeSet = modeled
+                ? buildStrictWriteSet({ claim: modeled, statement: claim.statement })
+                : null;
+            if (!modeled)
+                diagnostics.push(`Intent claim needs authoring at ${source.id}:${claim.reference}: ${claim.statement}`);
+        }
+        catch (error) {
+            diagnostics.push(`Intent claim extraction failed at ${source.id}:${claim.reference}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (writeSet?.isStrict &&
+            confidence >= minConfidence &&
+            !existingIds.has(writeSet.req.id)) {
+            candidates.push({
+                candidateId: `claim:${source.id}:${writeSet.req.id.toLowerCase()}`,
+                entityType: "req",
+                title: claim.statement,
+                sourceKind: "intent_claim",
+                sourcePath: claim.reference,
+                confidence,
+                confidenceBand: confidenceBand(confidence),
+                evidence,
+                relationships: writeSet.relationships.map(({ type, from, to }) => ({
+                    type,
+                    from,
+                    to,
+                })),
+                applyPlan: strictPlan(writeSet),
+            });
+            continue;
+        }
+        if (writeSet?.isStrict && existingIds.has(writeSet.req.id)) {
+            suppressed.push({
+                candidateId: `claim:${source.id}:${writeSet.req.id.toLowerCase()}`,
+                reason: "entity_exists",
+                sourcePath: claim.reference,
+                entityType: "req",
+            });
+            continue;
+        }
+        sourceOnlySignals.push({
+            kind: "req",
+            title: `Author requirement from ${source.title} ${claim.reference}: ${claim.statement}`,
+            sourcePath: claim.reference,
+            confidence,
+            evidence,
+        });
+    }
+    return { candidates, sourceOnlySignals, suppressed, diagnostics };
+}

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

@@ -2,6 +2,8 @@ import type { BootstrapEvidence, Candidate, SourceOnlySignal } from "./types.js"
 export type CandidateBuildResult = {
     readonly candidates: readonly Candidate[];
     readonly sourceOnlySignals: readonly SourceOnlySignal[];
+    readonly diagnostics: readonly string[];
+    readonly suppressed: readonly Readonly<Record<string, unknown>>[];
 };
 export declare function markdownCandidates(item: BootstrapEvidence, existingIds: ReadonlySet<string>, minConfidence: number): CandidateBuildResult;
 //# sourceMappingURL=markdown-candidates.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;IACxD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACnE,CAAC;AA4HF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,GACpB,oBAAoB,CAkFtB"}

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

@@ -1,7 +1,7 @@
 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";
+import { claimFor, normalizeClaimStatement } from "./requirement-claims.js";
 function headingSignals(heading, sourcePath, textRef, minConfidence) {
     const result = [];
     for (const [kind, pattern, confidence] of [
@@ -74,7 +74,7 @@ function requirementCandidate(item, statement, line, heading, headingLine, exist
     if (!claim)
         return null;
     const writeSet = buildStrictWriteSet({ claim, statement });
-    if (!writeSet.isStrict || existingIds.has(writeSet.req.id))
+    if (!writeSet.isStrict)
         return null;
     return {
         candidateId: `norm:${writeSet.req.id.toLowerCase()}`,
@@ -100,6 +100,7 @@ function requirementCandidate(item, statement, line, heading, headingLine, exist
 export function markdownCandidates(item, existingIds, minConfidence) {
     const candidates = [];
     const sourceOnlySignals = [];
+    const diagnostics = [];
     const relativePath = item.relativePath ?? item.label;
     let heading;
     let headingLine = 0;
@@ -121,15 +122,36 @@ export function markdownCandidates(item, existingIds, minConfidence) {
             sourceOnlySignals.push(...headingSignals(heading, item.absolutePath ?? relativePath, `${relativePath}#L${headingLine}`, minConfidence));
             continue;
         }
-        const statement = line
-            .replace(/^\s*[-*+]\s+/, "")
-            .replace(/^\s*\d+[.)]\s+/, "")
-            .trim();
+        const statement = normalizeClaimStatement(line);
         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);
+        try {
+            const candidate = requirementCandidate(item, statement, index + 1, heading, headingLine, existingIds, minConfidence);
+            if (candidate) {
+                if (!candidate.applyPlan.some((payload) => payload.type === "req" && existingIds.has(String(payload.id))))
+                    candidates.push(candidate);
+            }
+            else {
+                diagnostics.push(`Requirement needs authoring at ${relativePath}#L${index + 1}: ${statement}`);
+                sourceOnlySignals.push({
+                    kind: "req",
+                    title: `Author requirement: ${statement}`,
+                    sourcePath: `${relativePath}#L${index + 1}`,
+                    confidence: 0.8,
+                    evidence: [`normative_statement:${relativePath}#L${index + 1}`],
+                });
+            }
+        }
+        catch (error) {
+            diagnostics.push(`Requirement extraction failed at ${relativePath}#L${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+            sourceOnlySignals.push({
+                kind: "req",
+                title: `Review requirement: ${statement}`,
+                sourcePath: `${relativePath}#L${index + 1}`,
+                confidence: 0.8,
+                evidence: [`normative_statement:${relativePath}#L${index + 1}`],
+            });
+        }
     }
-    return { candidates, sourceOnlySignals };
+    return { candidates, sourceOnlySignals, diagnostics, suppressed: [] };
 }

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

@@ -11,5 +11,7 @@ export declare function presentBootstrap(input: {
     readonly suppressedCandidates: readonly Readonly<Record<string, unknown>>[];
     readonly expected: BootstrapPlanV1["expected"];
     readonly bindingDiagnostics?: readonly string[];
+    /** Advisory findings about declared context; they never block apply. */
+    readonly contextDiagnostics?: readonly string[];
 }): PlanBootstrapResult;
 //# sourceMappingURL=presentation.d.ts.map