kibi-mcp 0.17.5 → 0.19.0

package/dist/diagnostics-helpers.js

@@ -70,12 +70,32 @@ export function classifyDiagnosticError(error) {
         return buildErrorFields(err, "relationship_validation_failed", "validation", "Relationship payload failed schema validation.");
     if (err.message.startsWith("Relationship source must match the upserted entity"))
         return buildErrorFields(err, "relationship_source_mismatch", "validation", "Relationship source did not match the entity being upserted.");
+    if (lower.includes("contradiction detected for requirement")) {
+        const fields = buildErrorFields(err, "semantic_contradiction", "validation", "Requirement prose/facts contradict existing contradiction-ready requirements.");
+        return {
+            ...fields,
+            semantic_outcome: "conflict-blocked",
+            ...semanticContradictionIds(err.message),
+        };
+    }
     if (lower.includes("module load failed"))
         return buildErrorFields(err, "prolog_module_load_failed", "prolog_runtime", "Prolog failed to load an execution module.");
     if (lower.includes("query failed"))
         return buildErrorFields(err, "prolog_query_failed", "prolog_runtime", "Prolog query execution failed.");
     return buildErrorFields(err, "handler_error", "handler", "Unhandled MCP handler error.");
 }
+function semanticContradictionIds(message) {
+    const checked = message.match(/Contradiction detected for requirement\s+([^:\s]+)/i);
+    const conflicts = [
+        ...message.matchAll(/Conflicts with\s+([^:\s]+)/gi),
+    ].flatMap((match) => (match[1] ? [match[1]] : []));
+    return {
+        ...(checked?.[1] ? { semantic_checked_req_id: checked[1] } : {}),
+        ...(conflicts.length > 0
+            ? { semantic_conflicting_req_ids: conflicts }
+            : {}),
+    };
+}
 export function deriveDiagnosticHints(input) {
     const error = input.error instanceof Error ? input.error : new Error(String(input.error));
     const message = error.message.toLowerCase();
@@ -89,6 +109,8 @@ export function deriveDiagnosticHints(input) {
         return `tool_timeout ${mappedStage}: retry the same request after reducing payload size or scope.`;
     if (error_category === "relationship_source_mismatch")
         return `relationship_source_mismatch ${mappedStage}: align the relationship source with the upserted entity id.`;
+    if (error_category === "semantic_contradiction")
+        return `semantic_contradiction ${mappedStage}: add a supersedes relationship to the conflicting requirement, deprecate the older requirement, or align the modeled facts.`;
     if (error_category === "prolog_process_not_started")
         return `prolog_process_not_started ${mappedStage}: restart the MCP server before retrying the tool call.`;
     if (error_category === "prolog_query_failed")

package/dist/diagnostics.js

@@ -58,6 +58,88 @@ export const DIAGNOSTIC_TELEMETRY_SCHEMA = {
         },
     },
 };
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function structuredContentFrom(result) {
+    if (!isRecord(result))
+        return undefined;
+    const structuredContent = result.structuredContent;
+    return isRecord(structuredContent) ? structuredContent : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function suggestionKindsFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!isRecord(item) || typeof item.kind !== "string")
+            return [];
+        return [item.kind];
+    });
+}
+function appendSemanticAdvisorFields(fields, receipt) {
+    if (!isRecord(receipt))
+        return;
+    const readiness = receipt.logic_readiness;
+    const lane = receipt.candidate_lane;
+    const suggestionKinds = suggestionKindsFrom(receipt.suggestions);
+    if (typeof readiness === "string") {
+        fields.semantic_logic_readiness = readiness;
+    }
+    if (typeof lane === "string") {
+        fields.semantic_candidate_lane = lane;
+    }
+    fields.semantic_suggestion_kinds = suggestionKinds;
+    fields.semantic_suggestion_count = suggestionKinds.length;
+    fields.semantic_next_tools = stringArray(receipt.suggested_next_tools);
+}
+function appendPredicateSuggestionFields(fields, structuredContent) {
+    const candidates = Array.isArray(structuredContent.candidates)
+        ? structuredContent.candidates
+        : [];
+    const topCandidate = candidates.find(isRecord);
+    fields.predicate_candidate_count = candidates.length;
+    if (topCandidate) {
+        if (typeof topCandidate.predicate_name === "string") {
+            fields.predicate_top_name = topCandidate.predicate_name;
+        }
+        if (typeof topCandidate.score === "number") {
+            fields.predicate_top_score = topCandidate.score;
+        }
+    }
+    if (typeof structuredContent.recommendedAction === "string") {
+        fields.predicate_recommended_action = structuredContent.recommendedAction;
+    }
+    fields.predicate_relationship_plan = isRecord(structuredContent.relationshipPlan);
+}
+function appendContradictionCheckFields(fields, contradictionCheck) {
+    if (!isRecord(contradictionCheck))
+        return;
+    const outcome = contradictionCheck.outcome;
+    if (typeof outcome === "string") {
+        fields.semantic_contradiction_outcome = outcome;
+    }
+    const checkedReqId = contradictionCheck.checked_req_id;
+    if (typeof checkedReqId === "string") {
+        fields.semantic_checked_req_id = checkedReqId;
+    }
+    const strictReadiness = contradictionCheck.strict_readiness;
+    if (typeof strictReadiness === "string") {
+        fields.semantic_strict_readiness = strictReadiness;
+    }
+    const subjectKey = contradictionCheck.subject_key;
+    if (typeof subjectKey === "string") {
+        fields.semantic_subject_key = subjectKey;
+    }
+    const propertyKey = contradictionCheck.property_key;
+    if (typeof propertyKey === "string") {
+        fields.semantic_property_key = propertyKey;
+    }
+}
 export function deriveDiagnosticFields(toolName, args, telemetry, result) {
     const fields = {
         telemetry_status: telemetry ? "provided" : "missing",
@@ -67,10 +149,7 @@ export function deriveDiagnosticFields(toolName, args, telemetry, result) {
         fields.telemetry_confidence_score = telemetry.confidence_score ?? null;
         fields.telemetry_attempt_number = telemetry.attempt_number ?? null;
     }
-    const structuredContent = result && typeof result === "object" && "structuredContent" in result
-        ? result
-            .structuredContent
-        : undefined;
+    const structuredContent = structuredContentFrom(result);
     if (toolName === "kb_query" || toolName === "kb_search") {
         const resultCount = Number(structuredContent?.count ?? 0);
         fields.result_count = resultCount;
@@ -85,6 +164,36 @@ export function deriveDiagnosticFields(toolName, args, telemetry, result) {
         fields.result_summary =
             violationCount === 0 ? "0 violations" : `${violationCount} violations`;
     }
+    if (toolName === "kb_semantic_advisor" && structuredContent) {
+        appendSemanticAdvisorFields(fields, structuredContent.receipt);
+        const readiness = fields.semantic_logic_readiness;
+        const lane = fields.semantic_candidate_lane;
+        if (typeof readiness === "string" && typeof lane === "string") {
+            fields.result_summary = `semantic advisor ${readiness} via ${lane}`;
+        }
+    }
+    if (toolName === "kb_suggest_predicates" && structuredContent) {
+        appendPredicateSuggestionFields(fields, structuredContent);
+        const count = Number(fields.predicate_candidate_count ?? 0);
+        const topName = fields.predicate_top_name;
+        fields.result_summary =
+            typeof topName === "string"
+                ? `${count} predicate candidates; top=${topName}`
+                : `${count} predicate candidates`;
+    }
+    if (toolName === "kb_upsert" && structuredContent) {
+        const created = Number(structuredContent.created ?? 0);
+        const updated = Number(structuredContent.updated ?? 0);
+        fields.upsert_created = created;
+        fields.upsert_updated = updated;
+        fields.upsert_relationships_created = Number(structuredContent.relationships_created ?? 0);
+        appendContradictionCheckFields(fields, structuredContent.contradictionCheck);
+        appendSemanticAdvisorFields(fields, structuredContent.semanticAdvisor);
+        const readiness = fields.semantic_logic_readiness;
+        if (typeof readiness === "string") {
+            fields.result_summary = `upsert ${created > 0 ? "created" : "updated"}; semantic ${readiness}`;
+        }
+    }
     if (!fields.result_summary) {
         fields.result_summary = `${toolName} completed`;
     }

package/dist/semantic-advisor/analyze-prose.js

@@ -385,6 +385,16 @@ function detectStrictPropertySuggestion(payload, statement) {
             value_int: Number(comparative.groups.value),
         }, "Comparative numeric prose is a strict property constraint.", 0.86);
     }
+    const decisecondSlot = statement.match(/^.+?\s+(?:must|shall|should)\s+normalize\s+into\s+canonical\s+integer\s+decisecond\s+(?<subject>[a-z][a-z0-9_-]*)\s+values?\.?$/i);
+    if (decisecondSlot?.groups?.subject) {
+        return strictSuggestion(payload, decisecondSlot[0], {
+            subject_key: normalizeSubjectKey(decisecondSlot.groups.subject),
+            property_key: "slot_precision",
+            operator: "eq",
+            value_type: "string",
+            value_string: "decisecond",
+        }, "Canonical decisecond slot prose is a strict precision property.", 0.9);
+    }
     const threshold = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+return\s+within\s+(?<value>\d+)\s+(?<unit>ms|milliseconds?|s|sec|secs|seconds?)\.?$/i);
     if (threshold?.groups?.subject &&
         threshold.groups.value &&
@@ -598,6 +608,21 @@ function detectPredicateSuggestion(payload, statement) {
         };
         return predicateSuggestion(payload, ownership[0], predicate, "Ownership prose assigns responsibility for a resource or behavior and should be queryable as a predicate.");
     }
+    const mergePolicy = statement.match(/^(?<inputs>.+?)\s+saved\s+in\s+the\s+same\s+(?<slot>.+?)\s+must\s+merge\s+into\s+(?<target>.+?)\s+instead\s+of\s+creating\s+.+?\.?$/i);
+    if (mergePolicy?.groups?.inputs &&
+        mergePolicy.groups.slot &&
+        mergePolicy.groups.target) {
+        const inputs = normalizePredicateToken(mergePolicy.groups.inputs);
+        const slot = normalizePredicateToken(mergePolicy.groups.slot);
+        const target = normalizePredicateToken(mergePolicy.groups.target);
+        const predicate = {
+            predicate_name: "merge_policy",
+            predicate_args: [inputs, slot, target],
+            canonical_key: `merge_policy(${inputs},${slot},${target})`,
+            polarity: "assert",
+        };
+        return predicateSuggestion(payload, mergePolicy[0], predicate, "Same-slot merge prose defines ontology-lite merge behavior and should be queryable as a predicate.");
+    }
     const retryPolicy = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+retry\s+up\s+to\s+(?<count>\d+)\s+(?<unit>times|attempts?)\.?$/i);
     if (retryPolicy?.groups?.subject &&
         retryPolicy.groups.count &&

package/dist/server/docs.js

@@ -107,7 +107,7 @@ export const PROMPTS = [
             "- `kb_graph`: Bounded graph traversal from seed IDs",
             "- `kb_upsert`: Create or update entities and their relationships",
             "- `kb_delete`: Remove entities by ID (with dependency safety checks)",
-            "- `kb_check`: Validate KB integrity against configurable rules",
+            "- `kb_check`: Validate KB integrity against configurable rules; omit `rules` for final full validation plus full-KB `qualityDiagnostics[]` audit review",
             "",
             "Core modeling principles:",
             "- Kibi has eight entity types: common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).",
@@ -118,7 +118,7 @@ export const PROMPTS = [
             "- v1 contradictions are limited to exact-value, boolean/enum, numeric range, and polarity conflicts.",
             "- Use `kb_search` first for discovery, then `kb_query` for exact follow-up before any mutation.",
             "- Use `kb_upsert` and `kb_delete` only for intentional, traceable KB changes.",
-            "- Run `kb_check` after meaningful mutations to catch integrity issues early.",
+            "- Run `kb_check` with explicit `rules` during iteration for scoped feedback; run an unfiltered `kb_check` before completion to include the full-KB `qualityDiagnostics[]` audit scan.",
             "- Prefer explicit IDs and enum values to avoid invalid parameters.",
             "- Model requirements by first creating/reusing fact entities (create-before-link).",
             "- flag gates runtime/config behavior; use `fact` with `fact_kind: observation` or `meta` for bug and workaround notes.",
@@ -138,7 +138,8 @@ export const PROMPTS = [
             "5. **Model requirements as facts**: For new/updated reqs, create/reuse fact entities first, then express req semantics with `constrains` + `requires_property` (automated via `kb_model_requirement`).",
             "6. **Suggest predicates before prose**: For ontology-lane requirements, spell out the prose claim and call `kb_suggest_predicates` before writing `fact_kind: observation`. Apply the selected `fact_kind: predicate` applyPlan, then attach the returned `relationshipPlan` as `requires_predicate` while preserving existing req metadata; use the returned `review:ontology-gap` observation when no predicate fits.",
             "7. **Mutate**: Call `kb_upsert` for create/update, or `kb_delete` for explicit removals.",
-            "8. **Targeted checks**: Run `kb_check` after meaningful mutations; specify only the rules you need.",
+            "8. **Targeted checks**: Run `kb_check` after meaningful mutations; specify only the rules you need so scoped validation stays fast and skips the full-KB advisory scan.",
+            "9. **Final check**: Run `kb_check` without `rules` before completion so hard `violations[]` and advisory full-KB `qualityDiagnostics[]` are both reviewed.",
             "",
             "If a tool returns empty results, do not assume failure. Re-check filters (type, id, tags, sourceFile, limit, or offset).",
         ].join("\n"),
@@ -203,7 +204,7 @@ function registerDocResources() {
         "2. `kb_upsert` for the fact entity first (create-before-link)",
         "3. `kb_upsert` for the req entity and include `relationships` with `constrains` and `requires_property`",
         "4. Reuse the same constrained fact ID across related requirements; vary property facts only when semantics differ",
-        '5. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }` for targeted validation',
+        '5. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }` for targeted validation; supplying `rules` skips the full-KB advisory scan',
         "",
         "## Model requirements as ontology predicates",
         '1. Spell out the requirement prose and call `kb_suggest_predicates` with `{ "text": "...", "requirementId": "REQ-..." }`',
@@ -222,9 +223,9 @@ function registerDocResources() {
         '1. `kb_query` with `{ "type": "test" }` to check for existing test IDs',
         '2. `kb_query` with `{ "id": "REQ-XXX" }` to verify the requirement exists',
         "3. `kb_upsert` with entity payload and `relationships` containing `verified_by`",
-        '4. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }` for targeted validation',
+        '4. `kb_check` with `{ "rules": ["required-fields","no-dangling-refs"] }` for targeted validation; use an unfiltered `kb_check` before completion for full-KB `qualityDiagnostics[]`',
         "",
-        "Note: Always use query-first pattern. Specify only needed rules in kb_check for faster validation.",
+        "Note: Always use query-first pattern. Specify only needed rules in kb_check for faster iteration; omit rules for the final full validation and full-KB quality diagnostics review.",
     ].join("\n");
     return [
         {

package/dist/server/tool-registration.js

@@ -88,7 +88,10 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_validate_upsert",
-        handler: async (args) => runtime.handleKbValidateUpsert(args),
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbValidateUpsert(prolog, args);
+        },
     });
     register({
         name: "kb_delete",

package/dist/tools/check-config.js

@@ -0,0 +1,67 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
+// implements REQ-002
+export async function loadChecksConfig(workspaceRoot) {
+    const configPath = path.join(workspaceRoot, ".kb", "config.json");
+    try {
+        const content = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(content);
+        const parsedRules = parsed.checks?.rules;
+        const normalizedRules = {
+            ...DEFAULT_CHECKS_CONFIG.rules,
+        };
+        if (parsedRules && typeof parsedRules === "object") {
+            for (const [key, value] of Object.entries(parsedRules)) {
+                if (typeof value === "boolean") {
+                    normalizedRules[key] = value;
+                }
+            }
+        }
+        const parsedSt = parsed.checks?.symbolTraceability;
+        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
+        if (parsedSt &&
+            typeof parsedSt === "object" &&
+            typeof parsedSt.requireAdr === "boolean") {
+            normalizedSt.requireAdr = parsedSt.requireAdr;
+        }
+        return {
+            rules: normalizedRules,
+            symbolTraceability: normalizedSt,
+        };
+    }
+    catch {
+        return DEFAULT_CHECKS_CONFIG;
+    }
+}
+// implements REQ-002
+export function getEffectiveRules(configRules, requestedRules) {
+    if (requestedRules && requestedRules.length > 0) {
+        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
+    }
+    const effective = new Set();
+    for (const rule of RULE_NAMES) {
+        const enabled = configRules[rule] ?? true;
+        if (enabled) {
+            effective.add(rule);
+        }
+    }
+    return effective;
+}

package/dist/tools/check-format.js

@@ -0,0 +1,92 @@
+function formatDiagnosticsForMcp(diagnostics) {
+    return diagnostics.map((d) => ({
+        category: d.category,
+        severity: d.severity,
+        message: d.message,
+        ...(d.file !== undefined ? { file: d.file } : {}),
+        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
+    }));
+}
+export function formatImpactText(impactResult) {
+    if (impactResult.impactDiagnostics.length === 0) {
+        return "No impact diagnostics found";
+    }
+    const details = impactResult.impactDiagnostics.map((diagnostic) => {
+        const files = diagnostic.files.length > 0
+            ? diagnostic.files.join(", ")
+            : "unknown-source";
+        return `- ${diagnostic.id} | ${diagnostic.severity} | ${files} | ${diagnostic.message} Suggestion: ${diagnostic.suggestion}`;
+    });
+    return `${impactResult.impactDiagnostics.length} impact diagnostics found\n${details.join("\n")}`;
+}
+function formatOptionalList(label, values) {
+    if (values === undefined || values.length === 0) {
+        return [];
+    }
+    return [`${label}: ${values.join(", ")}`];
+}
+export function formatQualityDiagnosticsText(diagnostics) {
+    if (diagnostics.length === 0) {
+        return "No quality diagnostics found";
+    }
+    const details = diagnostics.map((diagnostic) => {
+        const parts = [
+            diagnostic.id,
+            diagnostic.severity,
+            diagnostic.category,
+            diagnostic.message,
+        ];
+        const metadata = [
+            `Blocking: ${diagnostic.blocking ? "yes" : "no"}`,
+            ...formatOptionalList("Files", diagnostic.files),
+            ...formatOptionalList("Docs", diagnostic.docs),
+            ...(diagnostic.entityId !== undefined
+                ? [`Entity: ${diagnostic.entityId}`]
+                : []),
+            ...(diagnostic.source !== undefined
+                ? [`Source: ${diagnostic.source}`]
+                : []),
+            `Suggestion: ${diagnostic.suggestion}`,
+        ];
+        return `- ${parts.join(" | ")}\n  ${metadata.join("\n  ")}`;
+    });
+    return `${diagnostics.length} quality diagnostic${diagnostics.length === 1 ? "" : "s"} found\n${details.join("\n")}`;
+}
+export function buildStructuredContent(input) {
+    const qualityDiagnostics = input.qualityDiagnostics ?? [];
+    return {
+        violations: [...input.violations],
+        count: input.violations.length,
+        diagnostics: formatDiagnosticsForMcp(input.diagnostics),
+        ...(qualityDiagnostics.length > 0
+            ? { qualityDiagnostics: [...qualityDiagnostics] }
+            : {}),
+        ...(input.impactResult
+            ? {
+                impactDiagnostics: input.impactResult.impactDiagnostics,
+                sourceFiles: input.impactResult.sourceFiles,
+                extractedSymbols: input.impactResult.extractedSymbols,
+                linkedEntities: input.impactResult.linkedEntities,
+                nextActions: input.impactResult.nextActions,
+            }
+            : {}),
+    };
+}
+export function formatViolationText(violations) {
+    if (violations.length === 0) {
+        return "No violations found";
+    }
+    const details = violations.map((violation) => {
+        const parts = [
+            violation.rule,
+            violation.entityId,
+            violation.source ?? "unknown-source",
+            violation.description,
+        ];
+        if (violation.suggestion) {
+            parts.push(`Suggestion: ${violation.suggestion}`);
+        }
+        return `- ${parts.join(" | ")}`;
+    });
+    return `${violations.length} violations found\n${details.join("\n")}`;
+}

package/dist/tools/check-impact.js

@@ -0,0 +1,45 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { analyzeChangedFileImpact, } from "kibi-cli/public/impact-diagnostics";
+export function hasImpactOptions(args) {
+    return Boolean(args.includeImpactDiagnostics ||
+        args.staged ||
+        args.includeWorkingTreeDiff ||
+        (args.sourceFiles && args.sourceFiles.length > 0));
+}
+export function analyzeKbCheckImpact(workspaceRoot, args) {
+    if (!hasImpactOptions(args)) {
+        return undefined;
+    }
+    return analyzeChangedFileImpact({
+        workspaceRoot,
+        ...(args.sourceFiles !== undefined
+            ? { sourceFiles: args.sourceFiles }
+            : {}),
+        ...(args.staged !== undefined ? { staged: args.staged } : {}),
+        ...(args.includeWorkingTreeDiff !== undefined
+            ? { includeWorkingTreeDiff: args.includeWorkingTreeDiff }
+            : {}),
+        ...(args.includeImpactDiagnostics !== undefined
+            ? { includeImpactDiagnostics: args.includeImpactDiagnostics }
+            : {}),
+        ...(args.maxDiagnostics !== undefined
+            ? { maxDiagnostics: args.maxDiagnostics }
+            : {}),
+    });
+}

package/dist/tools/check-prolog.js

@@ -0,0 +1,51 @@
+import { resolveCorePlPath } from "./core-module.js";
+import { collectQueryPlanSafetyViolations } from "./query-plan-safety.js";
+// implements REQ-002
+export async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
+    const violations = [];
+    const checksPlPath = resolveCorePlPath("checks.pl");
+    if (rulesAllowlist.has("query-plan-safety")) {
+        violations.push(...collectQueryPlanSafetyViolations(checksPlPath));
+    }
+    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
+    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
+    const requireAdrStr = requireAdr ? "true" : "false";
+    const query = `(load_files('${checksPlPathEscaped}', [if(changed)]),
+    (   predicate_property(checks:check_all_json_with_options(_, _), _)
+    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
+    ;   call(checks:check_all_json(JsonString))
+    ))`;
+    const result = await prolog.query(query);
+    if (!result.success) {
+        throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);
+    }
+    const violationsDict = parseViolations(result.bindings.JsonString);
+    for (const ruleViolations of Object.values(violationsDict)) {
+        for (const v of ruleViolations) {
+            const isAllowed = rulesAllowlist.has(v.rule);
+            if (isAllowed) {
+                violations.push({
+                    rule: v.rule,
+                    entityId: v.entityId,
+                    description: v.description,
+                    ...(v.suggestion ? { suggestion: v.suggestion } : {}),
+                    ...(v.source ? { source: v.source } : {}),
+                });
+            }
+        }
+    }
+    return violations;
+}
+function parseViolations(jsonString) {
+    try {
+        if (!jsonString || typeof jsonString !== "string") {
+            throw new Error("No JSON string in binding");
+        }
+        const parsed = JSON.parse(jsonString);
+        const violations = typeof parsed === "string" ? JSON.parse(parsed) : parsed;
+        return violations;
+    }
+    catch (parseError) {
+        throw new Error(`Failed to parse violations JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    }
+}

package/dist/tools/check-types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/check.js

@@ -1,99 +1,24 @@
-/*
- Kibi — repo-local, per-branch, queryable long-term memory for software projects
- Copyright (C) 2026 Piotr Franczyk
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-import { readFile } from "node:fs/promises";
-import * as path from "node:path";
-import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
+import { collectFullKbQualityDiagnostics, } from "kibi-cli/public/impact-diagnostics";
 import { resolveWorkspaceRoot } from "../workspace.js";
-import { resolveCorePlPath } from "./core-module.js";
-function formatDiagnosticsForMcp(diagnostics) {
-    return diagnostics.map((d) => ({
-        category: d.category,
-        severity: d.severity,
-        message: d.message,
-        ...(d.file !== undefined ? { file: d.file } : {}),
-        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
-    }));
-}
-function formatViolationText(violations) {
-    if (violations.length === 0) {
-        return "No violations found";
-    }
-    const details = violations.map((violation) => {
-        const parts = [
-            violation.rule,
-            violation.entityId,
-            violation.source ?? "unknown-source",
-            violation.description,
-        ];
-        if (violation.suggestion) {
-            parts.push(`Suggestion: ${violation.suggestion}`);
-        }
-        return `- ${parts.join(" | ")}`;
-    });
-    return `${violations.length} violations found\n${details.join("\n")}`;
-}
-// implements REQ-002
-async function loadChecksConfig(workspaceRoot) {
-    const configPath = path.join(workspaceRoot, ".kb", "config.json");
-    try {
-        const content = await readFile(configPath, "utf8");
-        const parsed = JSON.parse(content);
-        const parsedRules = parsed.checks?.rules;
-        const normalizedRules = {
-            ...DEFAULT_CHECKS_CONFIG.rules,
-        };
-        if (parsedRules && typeof parsedRules === "object") {
-            for (const [key, value] of Object.entries(parsedRules)) {
-                if (typeof value === "boolean") {
-                    normalizedRules[key] = value;
-                }
-                // Ignore non-boolean values (they are not added to normalizedRules, preserving defaults)
-            }
-        }
-        const parsedSt = parsed.checks?.symbolTraceability;
-        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
-        if (parsedSt && typeof parsedSt === "object") {
-            if (typeof parsedSt.requireAdr === "boolean") {
-                normalizedSt.requireAdr = parsedSt.requireAdr;
-            }
-        }
-        return {
-            rules: normalizedRules,
-            symbolTraceability: normalizedSt,
-        };
-    }
-    catch {
-        return DEFAULT_CHECKS_CONFIG;
+import { getEffectiveRules, loadChecksConfig } from "./check-config.js";
+import { buildStructuredContent, formatImpactText, formatQualityDiagnosticsText, formatViolationText, } from "./check-format.js";
+import { analyzeKbCheckImpact } from "./check-impact.js";
+import { runAggregatedChecks } from "./check-prolog.js";
+function qualityDiagnosticsFromImpact(impactResult) {
+    if (impactResult === undefined) {
+        return [];
     }
+    return impactResult.impactDiagnostics.filter((diagnostic) => !diagnostic.blocking && diagnostic.severity !== "error");
 }
-// implements REQ-002
-function getEffectiveRules(configRules, requestedRules) {
-    if (requestedRules && requestedRules.length > 0) {
-        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
+function buildSummary(input) {
+    const sections = [formatViolationText(input.violations)];
+    if (input.impactResult !== undefined) {
+        sections.push(formatImpactText(input.impactResult));
     }
-    const effective = new Set();
-    for (const rule of RULE_NAMES) {
-        const enabled = configRules[rule] ?? true;
-        if (enabled) {
-            effective.add(rule);
-        }
+    if (input.qualityDiagnostics.length > 0) {
+        sections.push(formatQualityDiagnosticsText(input.qualityDiagnostics));
     }
-    return effective;
+    return sections.join("\n");
 }
 /**
  * Handle kb_check tool calls - run validation rules on the KB
@@ -102,18 +27,41 @@ function getEffectiveRules(configRules, requestedRules) {
 // implements REQ-002
 export async function handleKbCheck(prolog, args) {
     const { rules, workspaceRoot: workspaceOverride } = args;
+    const hasExplicitRules = rules !== undefined;
     try {
         const workspaceRoot = workspaceOverride ?? resolveWorkspaceRoot();
         const checksConfig = await loadChecksConfig(workspaceRoot);
         const rulesAllowlist = getEffectiveRules(checksConfig.rules, rules);
+        const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
+        const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
         if (rulesAllowlist.size === 0) {
+            const qualityDiagnostics = hasExplicitRules
+                ? []
+                : impactResult
+                    ? impactQualityDiagnostics
+                    : await collectFullKbQualityDiagnostics({
+                        prolog,
+                        ...(args.maxDiagnostics !== undefined
+                            ? { maxDiagnostics: args.maxDiagnostics }
+                            : {}),
+                    });
             return {
-                content: [{ type: "text", text: "No violations found" }],
-                structuredContent: {
+                content: [
+                    {
+                        type: "text",
+                        text: buildSummary({
+                            violations: [],
+                            impactResult,
+                            qualityDiagnostics,
+                        }),
+                    },
+                ],
+                structuredContent: buildStructuredContent({
                     violations: [],
-                    count: 0,
                     diagnostics: [],
-                },
+                    qualityDiagnostics,
+                    impactResult,
+                }),
             };
         }
         // Ensure we read the latest KB state, not a cached snapshot.
@@ -128,7 +76,22 @@ export async function handleKbCheck(prolog, args) {
             ...(v.source !== undefined ? { file: v.source } : {}),
             ...(v.suggestion !== undefined ? { suggestion: v.suggestion } : {}),
         }));
-        const summary = formatViolationText(aggregatedViolations);
+        const qualityDiagnostics = hasExplicitRules
+            ? impactQualityDiagnostics
+            : impactResult
+                ? impactQualityDiagnostics
+                : await collectFullKbQualityDiagnostics({
+                    prolog,
+                    hardViolationEntityIds: new Set(aggregatedViolations.map((violation) => violation.entityId)),
+                    ...(args.maxDiagnostics !== undefined
+                        ? { maxDiagnostics: args.maxDiagnostics }
+                        : {}),
+                });
+        const summary = buildSummary({
+            violations: aggregatedViolations,
+            impactResult,
+            qualityDiagnostics,
+        });
         return {
             content: [
                 {
@@ -136,11 +99,12 @@ export async function handleKbCheck(prolog, args) {
                     text: summary,
                 },
             ],
-            structuredContent: {
+            structuredContent: buildStructuredContent({
                 violations: aggregatedViolations,
-                count: aggregatedViolations.length,
-                diagnostics: formatDiagnosticsForMcp(diagnostics),
-            },
+                diagnostics,
+                qualityDiagnostics,
+                impactResult,
+            }),
         };
     }
     catch (error) {
@@ -148,51 +112,3 @@ export async function handleKbCheck(prolog, args) {
         throw new Error(`Check execution failed: ${message}`);
     }
 }
-// implements REQ-002
-async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
-    const violations = [];
-    const checksPlPath = resolveCorePlPath("checks.pl");
-    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
-    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
-    // Use check_all_json_with_options if available, otherwise fall back to check_all_json
-    const requireAdrStr = requireAdr ? "true" : "false";
-    const query = `(use_module('${checksPlPathEscaped}'),
-    (   predicate_property(checks:check_all_json_with_options(_, _), _)
-    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
-    ;   call(checks:check_all_json(JsonString))
-    ))`;
-    const result = await prolog.query(query);
-    if (!result.success) {
-        throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);
-    }
-    let violationsDict;
-    try {
-        const jsonString = result.bindings.JsonString;
-        if (!jsonString) {
-            throw new Error("No JSON string in binding");
-        }
-        let parsed = JSON.parse(jsonString);
-        if (typeof parsed === "string") {
-            parsed = JSON.parse(parsed);
-        }
-        violationsDict = parsed;
-    }
-    catch (parseError) {
-        throw new Error(`Failed to parse violations JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
-    }
-    for (const ruleViolations of Object.values(violationsDict)) {
-        for (const v of ruleViolations) {
-            const isAllowed = rulesAllowlist.has(v.rule);
-            if (isAllowed) {
-                violations.push({
-                    rule: v.rule,
-                    entityId: v.entityId,
-                    description: v.description,
-                    ...(v.suggestion ? { suggestion: v.suggestion } : {}),
-                    ...(v.source ? { source: v.source } : {}),
-                });
-            }
-        }
-    }
-    return violations;
-}

package/dist/tools/query-plan-safety.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+const GENERATOR_PATTERN = /\b(?:kb_entity|kb_relationship|member|memberchk|findall|setof|bagof)\s*\(/;
+const NEGATION_PATTERN = /\\\+\s*/;
+export function collectQueryPlanSafetyViolations(checksPlPath) {
+    const source = fs.readFileSync(checksPlPath, "utf8");
+    return analyzeSource(source).map((violation) => ({
+        rule: "query-plan-safety",
+        entityId: violation.predicate,
+        description: violation.description,
+        suggestion: violation.suggestion,
+        source: `${checksPlPath}:${violation.line}`,
+    }));
+}
+function analyzeSource(source) {
+    const lines = source.split(/\r?\n/);
+    const violations = [];
+    let clauseStart = 0;
+    let predicate = "unknown";
+    let clauseLines = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (clauseLines.length === 0 && line.trim().length === 0) {
+            continue;
+        }
+        if (clauseLines.length === 0) {
+            clauseStart = index + 1;
+            predicate = predicateNameFrom(line) ?? "unknown";
+        }
+        clauseLines.push(line);
+        if (line.trim().endsWith(".")) {
+            const violation = analyzeClause(predicate, clauseStart, clauseLines);
+            if (violation)
+                violations.push(violation);
+            clauseLines = [];
+        }
+    }
+    return violations;
+}
+function predicateNameFrom(line) {
+    const match = line.match(/^\s*([a-z][a-zA-Z0-9_]*)\s*\(/);
+    return match?.[1] ?? null;
+}
+function analyzeClause(predicate, startLine, lines) {
+    const negationIndex = lines.findIndex((line) => NEGATION_PATTERN.test(line));
+    if (negationIndex < 0)
+        return null;
+    const hasLaterGenerator = lines
+        .slice(negationIndex + 1)
+        .some((line) => GENERATOR_PATTERN.test(line));
+    if (!hasLaterGenerator)
+        return null;
+    return {
+        predicate,
+        line: startLine + negationIndex,
+        description: "Negation appears before later generator calls in the same clause.",
+        suggestion: "Move kb_entity/kb_relationship/member/findall generators before \\+/1 so variables are bound before negation.",
+    };
+}

package/dist/tools/relationship-validation.js

@@ -0,0 +1,118 @@
+import { escapeAtom, toPrologAtom } from "kibi-cli/prolog/codec";
+function getStringField(record, field) {
+    const value = record[field];
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`Relationship ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function normalizePrologAtom(value) {
+    return value.replace(/^['"]|['"]$/g, "");
+}
+async function resolveEndpointType(input) {
+    if (input.endpointId === input.entity.id) {
+        const type = input.entity.type;
+        if (typeof type === "string" && type.trim() !== "") {
+            return type;
+        }
+    }
+    let result;
+    try {
+        result = await input.prolog.query(`kb_entity('${escapeAtom(input.endpointId)}', Type, _)`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return null;
+        }
+        throw error;
+    }
+    if (!result.success) {
+        return null;
+    }
+    const rawType = result.bindings?.Type;
+    if (typeof rawType !== "string" || rawType.trim() === "") {
+        return null;
+    }
+    return normalizePrologAtom(rawType);
+}
+function relationshipRecipe(tuple) {
+    if (tuple.relType === "verified_by" &&
+        tuple.fromType === "fact" &&
+        tuple.toType === "test") {
+        return [
+            "Facts are not directly verified by tests.",
+            "Create or update a requirement and link REQ -> TEST with verified_by.",
+            "Link the requirement to the fact with constrains or requires_property.",
+        ].join(" ");
+    }
+    if (tuple.relType === "validates" &&
+        tuple.fromType === "test" &&
+        tuple.toType === "fact") {
+        return [
+            "Tests validate requirements or scenarios, not facts directly.",
+            "Create or update a requirement and link TEST -> REQ with validates.",
+            "Link the requirement to the fact with constrains or requires_property.",
+        ].join(" ");
+    }
+    if (tuple.relType === "verified_by") {
+        return "verified_by is only valid as req/scenario -> test.";
+    }
+    if (tuple.relType === "validates") {
+        return "validates is only valid as test -> req/scenario.";
+    }
+    return "Use a typed relationship from docs/entity-schema.md, or relates_to only as a reviewed escape hatch.";
+}
+export function formatInvalidRelationshipTuple(tuple) {
+    return `Invalid relationship: ${tuple.relType} from ${tuple.fromType} to ${tuple.toType}. ${relationshipRecipe(tuple)}`;
+}
+export function formatInvalidRelationshipError(rawError) {
+    const placeholderMatch = rawError.match(/Invalid relationship:\s*~w from ~w to ~w-\[([^,\]]+),([^,\]]+),([^\]]+)\]/);
+    if (placeholderMatch) {
+        const [, relType, fromType, toType] = placeholderMatch;
+        if (relType && fromType && toType) {
+            return formatInvalidRelationshipTuple({ relType, fromType, toType });
+        }
+    }
+    const readableMatch = rawError.match(/Invalid relationship:\s*([^\s]+) from ([^\s]+) to ([^\s.]+)/);
+    if (readableMatch) {
+        const [, relType, fromType, toType] = readableMatch;
+        if (relType && fromType && toType) {
+            return formatInvalidRelationshipTuple({ relType, fromType, toType });
+        }
+    }
+    return null;
+}
+export function formatRelationshipSourceMismatch(entityId, relationship) {
+    const from = getStringField(relationship, "from");
+    const to = getStringField(relationship, "to");
+    return [
+        `Relationship source must match the upserted entity ${entityId}; received from=${from}.`,
+        `To add ${from} -> ${to}, upsert ${from} instead and include the relationship in that call.`,
+    ].join(" ");
+}
+export async function validateLiveRelationshipTargets(prolog, entity, relationships) {
+    for (const relationship of relationships) {
+        const fromType = await resolveEndpointType({
+            prolog,
+            entity,
+            endpointId: getStringField(relationship, "from"),
+        });
+        const toType = await resolveEndpointType({
+            prolog,
+            entity,
+            endpointId: getStringField(relationship, "to"),
+        });
+        if (fromType === null || toType === null) {
+            continue;
+        }
+        const tuple = {
+            relType: getStringField(relationship, "type"),
+            fromType,
+            toType,
+        };
+        const result = await prolog.query(`once(kb:validate_relationship(${toPrologAtom(tuple.relType)}, ${toPrologAtom(tuple.fromType)}, ${toPrologAtom(tuple.toType)}))`);
+        if (!result.success) {
+            throw new Error(formatInvalidRelationshipTuple(tuple));
+        }
+    }
+}

package/dist/tools/skills.js

@@ -36,7 +36,7 @@ export async function handleKbSkillsLoad(args) {
             content: [
                 {
                     type: "text",
-                    text: `Loaded bundled skill ${bundle.manifest.id} with ${resources.length} resources`,
+                    text: `Loaded bundled skill ${bundle.manifest.id} with ${resources.length} resources: ${formatResourceList(resources)}`,
                 },
             ],
             structuredContent: payload,
@@ -65,7 +65,25 @@ export async function handleKbSkillsRead(args) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Skills read failed: ${message}`);
+        throw new Error(`Skills read failed: ${message}${resourceListHint(args.id)}`);
+    }
+}
+function formatResourceList(resources) {
+    return resources.length === 0 ? "none" : resources.join(", ");
+}
+function resourceListHint(id) {
+    if (typeof id !== "string" || id.trim() === "") {
+        return "";
+    }
+    try {
+        const bundle = loadBundledSkill(id);
+        return `. Declared resources: ${formatResourceList(bundle.manifest.resources ?? [])}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return "";
+        }
+        throw error;
     }
 }
 function assertNonEmptyString(value, field) {

package/dist/tools/upsert.js

@@ -27,6 +27,7 @@ import { isMcpDebugEnabled } from "../env.js";
 import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
 import { readBranchKbStamp } from "../server/kb-freshness.js";
 import { attachedBranchKbPath, updateAttachedBranchStamp, } from "../server/session.js";
+import { formatInvalidRelationshipError, formatRelationshipSourceMismatch, validateLiveRelationshipTargets, } from "./relationship-validation.js";
 import { refreshCoordinatesForSymbolId } from "./symbols.js";
 let refreshCoordinatesForSymbolIdImpl = refreshCoordinatesForSymbolId;
 const ajv = new Ajv({ strict: false });
@@ -209,6 +210,7 @@ export async function handleKbUpsert(prolog, args) {
         // Validate strict-lane fact_kind pairing for constrains/requires_property
         // implements REQ-011
         await validateStrictLanePairing(prolog, effectiveRelationships);
+        await validateLiveRelationshipTargets(prolog, entity, effectiveRelationships);
         // Process entities
         for (const entity of entities) {
             const id = entity.id;
@@ -318,6 +320,19 @@ export async function handleKbUpsert(prolog, args) {
                 relationships_created: relationshipsCreated,
                 warnings: [...semanticAdvisor.warnings, ...coverageWarnings],
                 semanticAdvisor: semanticAdvisor.receipt,
+                ...(type === "req"
+                    ? {
+                        contradictionCheck: {
+                            outcome: args._skipContradictionCheck
+                                ? "skipped"
+                                : "no-conflict",
+                            checked_req_id: entity.id,
+                            strict_readiness: semanticAdvisor.receipt.logic_readiness === "modeled"
+                                ? "modeled"
+                                : semanticAdvisor.receipt.candidate_lane,
+                        },
+                    }
+                    : {}),
             },
         };
     }
@@ -508,6 +523,9 @@ function buildPropertyList(entity) {
         "priority",
         "severity",
         "symbol_role",
+        "granularity_reason",
+        "verification_scope",
+        "verification_perspective",
         // Typed fact enum fields must be atoms for Prolog validation
         "fact_kind",
         "operator",
@@ -587,7 +605,7 @@ function buildRelationshipMetadata(rel) {
 function validateRelationshipSources(entityId, relationships) {
     for (const rel of relationships) {
         if (rel.from !== entityId) {
-            throw new Error(`Relationship source must match the upserted entity ${entityId}; received from=${String(rel.from)}`);
+            throw new Error(formatRelationshipSourceMismatch(entityId, rel));
         }
     }
 }
@@ -766,6 +784,10 @@ function formatUpsertError(entityId, rawError) {
     if (!rawError) {
         return `Failed to upsert entity ${entityId}: Unknown error`;
     }
+    const invalidRelationshipError = formatInvalidRelationshipError(rawError);
+    if (invalidRelationshipError !== null) {
+        return `Failed to upsert entity ${entityId}: ${invalidRelationshipError}`;
+    }
     // Check for contradiction error - Prolog returns kb_contradiction([...]) term
     // Try to extract readable details from the term
     const contradictionMatch = rawError.match(/kb_contradiction\(\s*\[([^\]]+)\]\s*\)/);

package/dist/tools/validate-upsert.js

@@ -1,8 +1,20 @@
 import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
+import { validateLiveRelationshipTargets } from "./relationship-validation.js";
 import { validateKbUpsertArgs } from "./upsert.js";
-export async function handleKbValidateUpsert(args) {
+function isUpsertArgs(value) {
+    return "type" in value && "id" in value && "properties" in value;
+}
+export async function handleKbValidateUpsert(prologOrArgs, maybeArgs) {
     try {
+        const args = maybeArgs ?? (isUpsertArgs(prologOrArgs) ? prologOrArgs : null);
+        if (args === null) {
+            throw new Error("kb_validate_upsert requires an upsert payload");
+        }
+        const prolog = maybeArgs === undefined ? null : prologOrArgs;
         const { entity } = validateKbUpsertArgs(args);
+        if (prolog !== null && !isUpsertArgs(prolog)) {
+            await validateLiveRelationshipTargets(prolog, entity, args.relationships ?? []);
+        }
         const semanticAdvisor = analyzeSemanticAdvisorInput({
             payload: { ...args },
         });

package/dist/tools-config.js

@@ -421,6 +421,16 @@ const BASE_TOOLS = [
                             ],
                             description: "Optional role classification for symbol entities. Example: 'behavioral'.",
                         },
+                        verification_scope: {
+                            type: "string",
+                            enum: ["unit", "integration", "end_to_end"],
+                            description: "Optional typed verification scope for test entities. Example: 'end_to_end'.",
+                        },
+                        verification_perspective: {
+                            type: "string",
+                            enum: ["internal", "consumer"],
+                            description: "Optional typed verification perspective for test entities. Example: 'consumer'.",
+                        },
                         fact_kind: {
                             type: "string",
                             enum: [
@@ -592,7 +602,7 @@ const BASE_TOOLS = [
     },
     {
         name: "kb_check",
-        description: "Run KB validation rules and return violations. Use before or after mutations. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration.",
+        description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review.",
         inputSchema: {
             type: "object",
             properties: {
@@ -611,9 +621,37 @@ const BASE_TOOLS = [
                             "domain-contradictions",
                             "strict-fact-shape",
                             "strict-req-fact-pairing",
+                            "predicate-verifiability",
+                            "query-plan-safety",
                         ],
                     },
-                    description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing. If omitted, server runs all.",
+                    description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; if supplied, server preserves scoped validation and skips the full-KB advisory scan.",
+                },
+                sourceFiles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional repo-relative source files to inspect for early impact diagnostics. Use with includeImpactDiagnostics after meaningful source edits.",
+                },
+                staged: {
+                    type: "boolean",
+                    description: "When true, inspect staged source changes for impact diagnostics using the shared CLI impact analyzer without shelling out to kibi check.",
+                },
+                includeWorkingTreeDiff: {
+                    type: "boolean",
+                    description: "When true, inspect current unstaged working-tree diffs for impact diagnostics. Pair with sourceFiles to scope the analysis.",
+                },
+                includeImpactDiagnostics: {
+                    type: "boolean",
+                    description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation and symbol_semantic_review_needed in structured output.",
+                },
+                maxDiagnostics: {
+                    type: "integer",
+                    minimum: 0,
+                    description: "Optional maximum number of impact diagnostics to return. Graph validation violations are not capped by this value.",
+                },
+                workspaceRoot: {
+                    type: "string",
+                    description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.",
                 },
             },
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.17.5",
+  "version": "0.19.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",
@@ -9,8 +9,8 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-cli": "^0.12.8",
-    "kibi-core": "^0.6.4",
+    "kibi-cli": "^0.14.0",
+    "kibi-core": "^0.7.0",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",
     "zod": "^4.3.6"