kibi-mcp 0.12.0 → 0.14.0

package/dist/server/docs.js

@@ -62,7 +62,7 @@ export const PROMPTS = [
             "Call `kb_autopilot_generate` with the gathered context to synthesize candidate entities.",
             "",
             "This tool is **read-only**. It returns additive `structuredContent` with:",
-            "- `promptBlock`: preview text for the user-facing approval prompt",
+            "- `promptBlock`: review text that can be surfaced in optional human-facing briefs",
             "- `recommendedActions`: agent-facing next steps, including any REQ/SCEN/TEST authoring routed for manual handling",
             "- `declaredContext`: the user-provided bootstrap context",
             "- `confidence`: confidence summary for the generated output",
@@ -70,19 +70,19 @@ export const PROMPTS = [
             "- `candidates`: synthesized entities grounded in declared context and source evidence",
             "- `discoverySummary`: source-backed discovery notes",
             "",
-            "## Step 3: Preview and Approval",
+            "## Step 3: Optional Human Review",
             "",
-            "Present the `promptBlock` and a summary of `candidates` to the user. **Wait for explicit approval** before proceeding to writes.",
+            "Surface the `promptBlock` and a summary of `candidates` when optional human review is useful. Human review is post-hoc/optional via VS Code briefs and must not block writes.",
             "",
-            "## Step 4: Apply Approved Candidates",
+            "## Step 4: Apply Candidates",
             "",
-            "Apply approved candidates sequentially using `kb_upsert`.",
-            "1. Execute each approved candidate's `applyPlan` in ascending phase order.",
+            "Apply candidates sequentially using `kb_upsert`.",
+            "1. Execute each candidate's `applyPlan` in ascending phase order.",
             "2. Confirm success of each `kb_upsert` before moving to the next.",
             "3. Run `kb_check` after the batch to verify KB integrity.",
             "",
             "## Rules",
-            "- Never apply changes without a user-facing preview and approval.",
+            "- Human review is optional and post-hoc via VS Code briefs; do not gate writes on synchronous sign-off.",
             "- `kb_autopilot_generate` is strictly read-only; synthesis is the backend, not the actor.",
             "- Guidance must stay MCP-only; do not suggest `kibi` CLI commands.",
         ].join("\n"),
@@ -135,7 +135,10 @@ export const PROMPTS = [
             "Core modeling principles:",
             "- Kibi has eight entity types: common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).",
             "- Encode requirements as linked facts: `req --constrains--> fact` plus `req --requires_property--> fact`.",
-            "- Only strict domain facts (`fact_kind: subject` + `property_value`) participate in contradiction inference; observation and meta facts are non-blocking notes.",
+            "- High-confidence modeling (>= 0.7) is fully automated; optional human review can happen post-hoc.",
+            "- Low-confidence claims (< 0.7) are downgraded to `observation` facts to prevent false-positive contradictions.",
+            "- Only strict domain facts participate in contradiction inference; observation and meta facts are non-blocking notes.",
+            "- 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.",
@@ -152,9 +155,10 @@ export const PROMPTS = [
             "Follow this sequence for reliable operation:",
             "",
             "1. **Discover first**: Call `kb_search` for exploratory discovery, then `kb_query` to confirm exact current state before mutation.",
-            "2. **Create-before-link**: Create endpoint entities with `kb_upsert` before linking them.",
-            "3. **Validate intent**: If creating links, call `kb_query` for both endpoint IDs first to ensure they exist.",
-            "4. **Model requirements as facts**: For new/updated reqs, create/reuse fact entities first, then express req semantics with `constrains` + `requires_property`.",
+            "2. **Check schema status**: Call `kb_status` to see if a schema migration is required for the branch KB.",
+            "3. **Create-before-link**: Create endpoint entities with `kb_upsert` before linking them.",
+            "4. **Validate intent**: If creating links, call `kb_query` for both endpoint IDs first to ensure they exist.",
+            "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`).",
             "5. **Mutate**: Call `kb_upsert` for create/update, or `kb_delete` for explicit removals.",
             "6. **Targeted checks**: Run `kb_check` after meaningful mutations; specify only the rules you need.",
             "",

package/dist/server/tools.js

@@ -11,6 +11,7 @@ import { handleKbQuery } from "../tools/query.js";
 import { handleKbSearch } from "../tools/search.js";
 import { handleKbStatus } from "../tools/status.js";
 import { handleKbUpsert } from "../tools/upsert.js";
+import { handleKbModelRequirement, } from "../tools/model-requirement.js";
 import { handleKbAutopilotGenerate, } from "../tools/autopilot-generate.js";
 import { handleKbBriefingGenerate, } from "../tools/briefing-generate.js";
 const defaultToolsServerDeps = {
@@ -59,6 +60,7 @@ const DEFAULT_TOOLS_RUNTIME = {
     handleKbSearch,
     handleKbStatus,
     handleKbUpsert,
+    handleKbModelRequirement,
     handleKbAutopilotGenerate,
     handleKbBriefingGenerate,
 };
@@ -321,6 +323,10 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
         const prolog = await runtime.ensureProlog();
         return runtime.handleKbCheck(prolog, args);
     }, runtime);
+    addTool(server, "kb_model_requirement", toolDef("kb_model_requirement").description, toolDef("kb_model_requirement").inputSchema, async (args) => {
+        const prolog = await runtime.ensureProlog();
+        return runtime.handleKbModelRequirement(prolog, args);
+    }, runtime);
     addTool(server, "kb_autopilot_generate", toolDef("kb_autopilot_generate").description, toolDef("kb_autopilot_generate").inputSchema, async (args) => {
         const prolog = await runtime.ensureProlog();
         return runtime.handleKbAutopilotGenerate(prolog, args);

package/dist/tools/autopilot-candidates.js

@@ -2,8 +2,11 @@
 // Implements candidate assembly from public CLI extractors
 import { extractFromManifest } from "kibi-cli/extractors/manifest";
 import { extractFromMarkdown } from "kibi-cli/extractors/markdown";
+import { buildStrictWriteSet, modelRequirementClaims, } from "kibi-cli/public/check-types";
 import path from "node:path";
 import fs from "node:fs";
+import { createRepoIgnorePolicy } from "kibi-cli/ignore-policy";
+import { estimateNormativeSignalConfidence, extractRequirementClaim, strictWriteSetToApplyPlan, writeSetPrimaryEntityId, } from "./model-requirement.js";
 function slugify(value, maxLength = 80) {
     return value
         .toLowerCase()
@@ -63,10 +66,8 @@ function resolveCandidatePaths(filePath, workspaceRoot) {
         .join("/");
     return { absolutePath, relativePath };
 }
-function isIgnoredGenericMarkdownPath(relativePath) {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
-    return /(^|\/)(documentation|\.kb|\.git|node_modules|vendor|vendors|third_party|third-party|dist|coverage)(\/|$)/.test(normalized);
-}
+// Legacy helper removed in favor of the shared ignore policy from kibi-cli/ignore-policy.
+// Use createRepoIgnorePolicy(workspaceRoot).isIgnored(relativePath) in builders.
 function shouldIncludeGenericMarkdown(relativePath, providerScopedMarkdown) {
     const base = path.basename(relativePath).toLowerCase();
     const inDocsDir = /(^|\/)docs\//.test(relativePath);
@@ -103,6 +104,7 @@ function buildUpsertFromExtraction(er, typeOverride) {
 export function buildTypedMarkdownCandidates(discoveryResult, existingEntities) {
     const candidates = [];
     const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    const ignorePolicy = createRepoIgnorePolicy(workspaceRoot);
     for (const filePath of getTypedMarkdownFiles(discoveryResult)) {
         try {
             const extraction = extractFromMarkdown(filePath);
@@ -110,6 +112,8 @@ export function buildTypedMarkdownCandidates(discoveryResult, existingEntities)
             if (existingEntities.ids.has(entity.id))
                 continue;
             const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
+            if (ignorePolicy.isIgnored(relativePath))
+                continue;
             const candidateId = `md:${relativePath}:${entity.id}`;
             const upsert = buildUpsertFromExtraction({ entity, relationships });
             candidates.push({
@@ -186,13 +190,14 @@ export function buildSymbolManifestCandidates(discoveryResult, existingEntities)
 export function buildGenericMarkdownCandidates(discoveryResult, existingEntities, minConfidence = 0.8) {
     const candidates = [];
     const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    const ignorePolicy = createRepoIgnorePolicy(workspaceRoot);
     const providerScopedMarkdown = hasGenericMarkdownEvidence(discoveryResult);
     const files = getGenericMarkdownFiles(discoveryResult);
     for (const rawPath of files) {
         try {
             const filePath = String(rawPath);
             const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
-            if (isIgnoredGenericMarkdownPath(relativePath))
+            if (ignorePolicy.isIgnored(relativePath))
                 continue;
             // Legacy path-only discovery was conservative. Provider-scoped discovery
             // already filters eligible generic docs, so allow broader repo markdown there.
@@ -287,12 +292,13 @@ export function collectSourceOnlyAuthoringSignals(discoveryResult, existingEntit
     const signals = [];
     const seen = new Set();
     const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    const ignorePolicy = createRepoIgnorePolicy(workspaceRoot);
     const providerScopedMarkdown = hasGenericMarkdownEvidence(discoveryResult);
     for (const rawPath of getGenericMarkdownFiles(discoveryResult)) {
         try {
             const filePath = String(rawPath);
             const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
-            if (isIgnoredGenericMarkdownPath(relativePath))
+            if (ignorePolicy.isIgnored(relativePath))
                 continue;
             if (!shouldIncludeGenericMarkdown(relativePath, providerScopedMarkdown))
                 continue;
@@ -370,6 +376,113 @@ export function collectSourceOnlyAuthoringSignals(discoveryResult, existingEntit
     });
 }
 // implements REQ-mcp-init-kibi-autopilot-v1
+export function buildNormativeRequirementCandidates(discoveryResult, existingEntities, minConfidence = 0.8) {
+    const candidates = [];
+    const seeds = [];
+    const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
+    const providerScopedMarkdown = hasGenericMarkdownEvidence(discoveryResult);
+    const ignorePolicy = createRepoIgnorePolicy(workspaceRoot);
+    for (const rawPath of getGenericMarkdownFiles(discoveryResult)) {
+        try {
+            const filePath = String(rawPath);
+            const { absolutePath, relativePath } = resolveCandidatePaths(filePath, workspaceRoot);
+            if (ignorePolicy.isIgnored(relativePath))
+                continue;
+            if (!shouldIncludeGenericMarkdown(relativePath, providerScopedMarkdown))
+                continue;
+            if (!fs.existsSync(absolutePath))
+                continue;
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const lines = content.split(/\r?\n/);
+            let activeHeading;
+            let activeHeadingLine;
+            let inCodeFence = false;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line === undefined)
+                    continue;
+                if (/^\s*(```|~~~)/.test(line)) {
+                    inCodeFence = !inCodeFence;
+                    continue;
+                }
+                if (inCodeFence)
+                    continue;
+                const headingMatch = line.match(/^\s*#+\s*(.+)$/);
+                if (headingMatch?.[1]) {
+                    activeHeading = headingMatch[1].trim();
+                    activeHeadingLine = i + 1;
+                    continue;
+                }
+                const statement = line
+                    .replace(/^\s*[-*+]\s+/, "")
+                    .replace(/^\s*\d+[.)]\s+/, "")
+                    .trim();
+                if (!statement || !/\b(must|shall|should)\b/i.test(statement))
+                    continue;
+                const confidence = estimateNormativeSignalConfidence(statement, activeHeading);
+                if (confidence < minConfidence)
+                    continue;
+                const extracted = extractRequirementClaim({
+                    text: statement,
+                    source: relativePath,
+                    confidence,
+                    provenance: `${relativePath}#L${i + 1}`,
+                });
+                const writeSet = buildStrictWriteSet({
+                    claim: extracted.claim,
+                    statement: extracted.statement,
+                });
+                if (!writeSet.isStrict)
+                    continue;
+                seeds.push({
+                    input: {
+                        claim: extracted.claim,
+                        statement: extracted.statement,
+                    },
+                    writeSet,
+                    sourcePath: absolutePath,
+                    evidence: [
+                        `normative_statement:${relativePath}#L${i + 1}`,
+                        ...(activeHeading && activeHeadingLine
+                            ? [`generic_heading:${relativePath}#L${activeHeadingLine}`]
+                            : []),
+                    ],
+                });
+            }
+        }
+        catch {
+            // ignore unreadable files when deriving strict requirement candidates
+        }
+    }
+    const modeledIds = new Set(modelRequirementClaims(seeds.map((seed) => seed.input)).map((writeSet) => writeSetPrimaryEntityId(writeSet)));
+    const emittedIds = new Set();
+    for (const seed of seeds) {
+        const entityId = writeSetPrimaryEntityId(seed.writeSet);
+        if (!modeledIds.has(entityId) || emittedIds.has(entityId))
+            continue;
+        if (existingEntities.ids.has(entityId))
+            continue;
+        emittedIds.add(entityId);
+        candidates.push({
+            candidateId: `norm:${entityId.toLowerCase()}`,
+            entityType: "req",
+            title: seed.input.statement,
+            sourceKind: "generic_markdown",
+            sourcePath: seed.sourcePath,
+            confidence: seed.writeSet.confidence,
+            confidenceBand: toConfidenceBand(seed.writeSet.confidence),
+            evidence: seed.evidence,
+            relationships: seed.writeSet.relationships.map((relationship) => ({
+                type: relationship.type,
+                from: relationship.from,
+                to: relationship.to,
+            })),
+            applyPlan: strictWriteSetToApplyPlan(seed.writeSet),
+        });
+    }
+    return candidates;
+}
+// implements REQ-mcp-init-kibi-autopilot-v1
 export function buildProviderEvidenceCandidates(discoveryResult, existingEntities, minConfidence = 0.8) {
     const candidates = [];
     const workspaceRoot = existingEntities.workspaceRoot ?? process.cwd();
@@ -431,5 +544,6 @@ export default {
     buildSymbolManifestCandidates,
     buildGenericMarkdownCandidates,
     collectSourceOnlyAuthoringSignals,
+    buildNormativeRequirementCandidates,
     buildProviderEvidenceCandidates,
 };

package/dist/tools/autopilot-discovery.js

@@ -7,6 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import fg from "fast-glob";
+import { createRepoIgnorePolicy } from "kibi-cli/ignore-policy";
 import * as cliSymbolCoordinator from "kibi-cli/extractors/symbols-coordinator";
 import { runJsonModuleQuery } from "./core-module.js";
 // implements REQ-001
@@ -211,7 +212,7 @@ function normalizeDiscoveryPaths(cwd) {
         symbols: readPath("symbols"),
     };
 }
-function buildIgnoredGlobs(vendoredRoots) {
+function buildIgnoredGlobs(vendoredRoots, workspaceRoot) {
     const ignored = new Set();
     for (const dirName of IGNORED_DIRECTORY_NAMES) {
         ignored.add(`**/${dirName}`);
@@ -226,6 +227,18 @@ function buildIgnoredGlobs(vendoredRoots) {
         ignored.add(`**/${normalized}`);
         ignored.add(`**/${normalized}/**`);
     }
+    // Use shared ignore policy to include .gitignore, nested ignores, and other rules.
+    try {
+        const policy = createRepoIgnorePolicy(workspaceRoot);
+        const globs = policy.getFastGlobIgnoreGlobs();
+        for (const glob of globs) {
+            if (glob)
+                ignored.add(glob);
+        }
+    }
+    catch {
+        // best-effort only
+    }
     return Array.from(ignored);
 }
 function detectLanguagesFromPaths(paths) {
@@ -266,6 +279,7 @@ function runTypedKibiDocsProvider(workspaceRoot) {
         onlyFiles: true,
         unique: true,
         suppressErrors: true,
+        ignore: buildIgnoredGlobs([], workspaceRoot),
     });
     const manifestFiles = discoveryPaths.symbols
         ? fg.sync(discoveryPaths.symbols, {
@@ -274,6 +288,7 @@ function runTypedKibiDocsProvider(workspaceRoot) {
             onlyFiles: true,
             unique: true,
             suppressErrors: true,
+            ignore: buildIgnoredGlobs([], workspaceRoot),
         })
         : [];
     const evidence = [
@@ -292,7 +307,7 @@ function runGenericRepoDocsProvider(workspaceRoot, vendoredRoots, typedFilePaths
         onlyFiles: true,
         unique: true,
         suppressErrors: true,
-        ignore: buildIgnoredGlobs(vendoredRoots),
+        ignore: buildIgnoredGlobs(vendoredRoots, workspaceRoot),
     });
     const evidence = sortUnique(markdownFiles)
         .map((absolutePath) => createFileEvidence("generic_repo_docs", "generic_markdown", workspaceRoot, absolutePath))
@@ -435,7 +450,7 @@ function runRepoLayoutProvider(workspaceRoot, vendoredRoots) {
         onlyFiles: true,
         unique: true,
         suppressErrors: true,
-        ignore: buildIgnoredGlobs(vendoredRoots),
+        ignore: buildIgnoredGlobs(vendoredRoots, workspaceRoot),
     });
     return {
         provider: "repo_layout",
@@ -468,7 +483,7 @@ function runTestTopologyProvider(workspaceRoot, vendoredRoots) {
         onlyFiles: true,
         unique: true,
         suppressErrors: true,
-        ignore: buildIgnoredGlobs(vendoredRoots),
+        ignore: buildIgnoredGlobs(vendoredRoots, workspaceRoot),
     });
     const detectedFrameworks = new Set();
     const detectedLanguages = new Set();
@@ -525,7 +540,7 @@ function runSourceSymbolsProvider(workspaceRoot, vendoredRoots) {
         onlyFiles: true,
         unique: true,
         suppressErrors: true,
-        ignore: buildIgnoredGlobs(vendoredRoots),
+        ignore: buildIgnoredGlobs(vendoredRoots, workspaceRoot),
     });
     const evidence = [];
     const detectedLanguages = new Set();

package/dist/tools/autopilot-generate.js

@@ -1,5 +1,8 @@
 import path from "node:path";
-import { collectSourceOnlyAuthoringSignals, buildGenericMarkdownCandidates, buildProviderEvidenceCandidates, buildTypedMarkdownCandidates, buildSymbolManifestCandidates, } from "./autopilot-candidates.js";
+import fg from "fast-glob";
+import { createRepoIgnorePolicy } from "kibi-cli/ignore-policy";
+import { buildNormativeRequirementCandidates, collectSourceOnlyAuthoringSignals, buildGenericMarkdownCandidates, buildProviderEvidenceCandidates, buildTypedMarkdownCandidates, buildSymbolManifestCandidates, } from "./autopilot-candidates.js";
+import { getWorkspaceMigrationWarning } from "./model-requirement.js";
 import { discoverProviderEvidence, resolveActivationPolicy, } from "./autopilot-discovery.js";
 import { loadEntities } from "./entity-query.js";
 import { resolveWorkspaceRoot } from "../workspace.js";
@@ -373,6 +376,7 @@ _prolog, args) {
     const activation = await resolveActivationPolicy(workspaceRoot, prolog);
     const activationState = activation.activationState;
     const activationDiscovery = discoverProviderEvidence(workspaceRoot, activation);
+    const migrationWarning = await getWorkspaceMigrationWarning(workspaceRoot);
     const declaredContext = normalizeBootstrapContext(bootstrapContext);
     const discoveredCandidatePaths = activationDiscovery.evidence.reduce((acc, item) => {
         const relativePath = item.relativePath;
@@ -405,6 +409,7 @@ _prolog, args) {
     let typedMarkdownCandidates = [];
     let manifestCandidates = [];
     let genericCandidates = [];
+    let normativeRequirementCandidates = [];
     let providerEvidenceCandidates = [];
     let allCandidates = [];
     const seenByKey = new Map();
@@ -427,6 +432,10 @@ _prolog, args) {
                 ids: existingIds,
                 workspaceRoot,
             }, normalizedMinConfidence);
+            normativeRequirementCandidates = buildNormativeRequirementCandidates(candidateDiscovery, {
+                ids: existingIds,
+                workspaceRoot,
+            }, normalizedMinConfidence);
         }
         providerEvidenceCandidates = buildProviderEvidenceCandidates(candidateDiscovery, {
             ids: existingIds,
@@ -436,6 +445,7 @@ _prolog, args) {
             ...typedMarkdownCandidates,
             ...manifestCandidates,
             ...genericCandidates,
+            ...normativeRequirementCandidates,
             ...providerEvidenceCandidates,
         ];
         if (entityTypes && entityTypes.length > 0) {
@@ -516,6 +526,40 @@ _prolog, args) {
             seenByKey.set(titleKey, record);
         }
     }
+    // Detect repository files that would be candidate inputs but are ignored by
+    // the repo ignore policy (e.g. .sisyphus drafts, .gitignore entries). Add
+    // them to suppressedCandidates with reason `ignored_source` so callers see
+    // why those files were omitted from candidate output.
+    try {
+        const repoIgnore = createRepoIgnorePolicy(workspaceRoot);
+        const potentialFiles = fg.sync(["**/*.md", "**/symbols.{yml,yaml}"], {
+            cwd: workspaceRoot,
+            absolute: true,
+            onlyFiles: true,
+            unique: true,
+            dot: true,
+            suppressErrors: true,
+        });
+        for (const absPath of potentialFiles) {
+            const rel = toWorkspaceRelativePath(workspaceRoot, absPath);
+            const explain = repoIgnore.explain(rel);
+            if (explain.ignored) {
+                // avoid duplicating existing suppressed entries for the same source
+                if (!suppressed.some((s) => String(s.sourcePath ?? "") === rel && s.reason === "ignored_source")) {
+                    suppressed.push({
+                        candidateId: String("") /* no candidate id for ignored source */,
+                        reason: "ignored_source",
+                        sourcePath: rel,
+                        entityType: String("") /* unknown at this stage */,
+                        detail: explain.reason,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // best-effort only; ignore failures here so generation can continue
+    }
     const candidateRecords = Array.from(seenByKey.values());
     const payoffSummary = buildPayoffSummary(candidateRecords);
     const promptBlock = buildPromptBlock(workspaceRoot, activationState, activation.activationMode, activation.reason, activation.applyBlocked, declaredContext, candidateRecords, sourceOnlySignals, activationDiscovery.summary.scanWarnings);
@@ -533,6 +577,7 @@ _prolog, args) {
         bootstrapMode: activation.activationMode,
         activationReason: activation.reason,
         applyBlocked: effectiveApplyBlocked,
+        migrationWarning,
         ...(activation.handoffMessage
             ? { handoffMessage: activation.handoffMessage }
             : {}),
@@ -554,6 +599,7 @@ _prolog, args) {
             },
         ],
         structuredContent,
+        migrationWarning,
         candidates: candidateRecords,
         suppressedCandidates: suppressed,
         payoffSummary,