kibi-cli 0.19.0 → 2.0.0

package/dist/public/operations/source-relationship-parity.js

@@ -0,0 +1,162 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { discoverSourceFiles } from "../../commands/sync/discovery.js";
+import { processExtractions } from "../../commands/sync/extraction.js";
+import { RELATIONSHIP_TYPES } from "../../operations/mutation/relationships.js";
+import { parseListOfLists, parsePrologValue } from "../../prolog/codec.js";
+import { readAllShards } from "../../relationships/shards.js";
+function relationshipKey(relationship) {
+    return `${relationship.type}\u0000${relationship.from}\u0000${relationship.to}`;
+}
+function relationshipLabel(relationship) {
+    return `${relationship.type} ${relationship.from}->${relationship.to}`;
+}
+// implements REQ-kibi-source-relationship-parity
+export function compareRelationshipParity(authored, compiled) {
+    const authoredByKey = new Map();
+    const compiledByKey = new Map();
+    for (const relationship of authored) {
+        authoredByKey.set(relationshipKey(relationship), relationship);
+    }
+    for (const relationship of compiled) {
+        compiledByKey.set(relationshipKey(relationship), relationship);
+    }
+    const violations = [];
+    for (const [key, relationship] of authoredByKey) {
+        if (compiledByKey.has(key))
+            continue;
+        violations.push({
+            rule: "source-relationship-parity",
+            entityId: relationship.from,
+            description: `Authored relationship is missing from the compiled KB: ${relationshipLabel(relationship)}`,
+            suggestion: "Run kibi sync after resolving semantic/source errors; do not delete authored links merely to make the compiled snapshot pass.",
+            ...(relationship.source !== undefined
+                ? { source: relationship.source }
+                : {}),
+            evidence: {
+                direction: "authored_to_compiled",
+                relationship: {
+                    type: relationship.type,
+                    from: relationship.from,
+                    to: relationship.to,
+                },
+            },
+        });
+    }
+    for (const [key, relationship] of compiledByKey) {
+        if (authoredByKey.has(key))
+            continue;
+        if (relationship.ownership === "runtime")
+            continue;
+        violations.push({
+            rule: "source-relationship-parity",
+            entityId: relationship.from,
+            description: `Compiled relationship has no authored Markdown or relationship-shard source: ${relationshipLabel(relationship)}`,
+            suggestion: "Restore the canonical authored relationship through kb_upsert, or remove the stale compiled edge through kb_delete after dependency review.",
+            evidence: {
+                direction: "compiled_to_authored",
+                relationship: {
+                    type: relationship.type,
+                    from: relationship.from,
+                    to: relationship.to,
+                },
+            },
+        });
+    }
+    return violations.sort((left, right) => `${left.entityId}\u0000${left.description}`.localeCompare(`${right.entityId}\u0000${right.description}`));
+}
+function isGitWorkspace(workspaceRoot) {
+    try {
+        return (execFileSync("git", ["-C", workspaceRoot, "rev-parse", "--is-inside-work-tree"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim() === "true");
+    }
+    catch {
+        return false;
+    }
+}
+async function compiledRelationships(prolog) {
+    const relationships = [];
+    for (const type of RELATIONSHIP_TYPES) {
+        const result = await prolog.query(`findall([From,To,Source], (kb_relationship(${type}, From, To), (kb_entity(From, _, Props), memberchk(source=RawSource, Props) -> normalize_term_atom(RawSource, Source) ; Source='')), Rows)`);
+        if (!result.success) {
+            throw new Error(`Unable to inspect compiled ${type} relationships: ${result.error ?? "query failed"}`);
+        }
+        relationships.push(...parseCompiledRelationshipRows(type, result.bindings.Rows ?? "[]"));
+    }
+    return relationships;
+}
+export function parseCompiledRelationshipRows(type, rows) {
+    return parseListOfLists(rows).flatMap(([rawFrom, rawTo, rawSource]) => {
+        const from = String(parsePrologValue(rawFrom ?? ""));
+        const to = String(parsePrologValue(rawTo ?? ""));
+        const source = String(parsePrologValue(rawSource ?? ""));
+        if (!from || !to)
+            return [];
+        return [
+            {
+                type,
+                from,
+                to,
+                ...(source ? { source } : {}),
+                ownership: source && /^[a-z][a-z0-9+.-]*:\/\//i.test(source)
+                    ? "runtime"
+                    : "authored",
+            },
+        ];
+    });
+}
+function authoredRelationship(relationship, source) {
+    return {
+        ...relationship,
+        source: source.replaceAll("\\", "/"),
+    };
+}
+// implements REQ-kibi-source-relationship-parity
+export async function collectSourceRelationshipParityViolations(workspaceRoot, prolog) {
+    if (!isGitWorkspace(workspaceRoot))
+        return [];
+    let discovery;
+    try {
+        discovery = await discoverSourceFiles(workspaceRoot, {
+            trackedOnly: true,
+            consumeTrackedPendingReceipts: false,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [
+            {
+                rule: "source-relationship-parity",
+                entityId: "source-discovery",
+                description: `Authored relationship parity could not establish a complete source view: ${message}`,
+                suggestion: "Repair the pending-source receipt through Kibi recovery, then rerun kb_check; do not ignore missing authored inputs.",
+                evidence: {
+                    direction: "source_discovery",
+                    message,
+                },
+            },
+        ];
+    }
+    const extraction = await processExtractions(discovery.markdownFiles, discovery.manifestFiles, true, workspaceRoot);
+    if (extraction.errors.length > 0) {
+        return extraction.errors.map(({ file, message }) => ({
+            rule: "source-relationship-parity",
+            entityId: path.relative(workspaceRoot, file).replaceAll(path.sep, "/"),
+            source: path.relative(workspaceRoot, file).replaceAll(path.sep, "/"),
+            description: `Authored relationship parity could not inspect source: ${message}`,
+            suggestion: "Repair the authored source, then rerun kb_check.",
+        }));
+    }
+    const authored = extraction.results.flatMap(({ entity, relationships }) => relationships.map((relationship) => authoredRelationship(relationship, entity.source)));
+    for (const relationship of readAllShards(path.join(workspaceRoot, ".kb"))) {
+        authored.push({
+            type: relationship.type,
+            from: relationship.from,
+            to: relationship.to,
+            source: ".kb/relationships",
+        });
+    }
+    return compareRelationshipParity(authored, await compiledRelationships(prolog));
+}

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

@@ -1,10 +1,10 @@
-import { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
-export type { AutopilotBootstrapContext, AutopilotGenerateArgs, AutopilotGenerateResult, } from "../../../operations/autopilot/types.js";
-export { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
-export declare const autopilotGenerateSpec: {
-    readonly name: "kb_autopilot_generate";
-    readonly cliName: "autopilot-generate";
-    readonly description: "Generate agent-centric bootstrap output for KB population. Read-only analysis that returns activation state, bootstrap guidance, candidate entities with evidence, payoff summary, and exact applyPlan payloads for later kb_upsert calls. No mutation side effects.";
+import { executePlanBootstrap } from "../../../operations/bootstrap/generate.js";
+export type { BootstrapContext, PlanBootstrapArgs, PlanBootstrapResult, } from "../../../operations/bootstrap/types.js";
+export { executePlanBootstrap } from "../../../operations/bootstrap/generate.js";
+export declare const planBootstrapSpec: {
+    readonly name: "kb_plan_bootstrap";
+    readonly cliName: "plan-bootstrap";
+    readonly description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -77,6 +77,6 @@ export declare const autopilotGenerateSpec: {
     };
     readonly requiresProlog: false;
     readonly effects: readonly ["workspace-read"];
-    readonly execute: typeof executeAutopilotGenerate;
+    readonly execute: typeof executePlanBootstrap;
 };
-//# sourceMappingURL=autopilot.d.ts.map
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/public/operations/specs/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAOjF,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAGjF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmF7B,CAAC"}

package/dist/public/operations/specs/{autopilot.js → bootstrap.js}

@@ -1,9 +1,10 @@
-import { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
-export { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
-export const autopilotGenerateSpec = {
-    name: "kb_autopilot_generate",
-    cliName: "autopilot-generate",
-    description: "Generate agent-centric bootstrap output for KB population. Read-only analysis that returns activation state, bootstrap guidance, candidate entities with evidence, payoff summary, and exact applyPlan payloads for later kb_upsert calls. No mutation side effects.",
+import { executePlanBootstrap } from "../../../operations/bootstrap/generate.js";
+export { executePlanBootstrap } from "../../../operations/bootstrap/generate.js";
+// implements REQ-KIBI-BOOTSTRAP-PLAN
+export const planBootstrapSpec = {
+    name: "kb_plan_bootstrap",
+    cliName: "plan-bootstrap",
+    description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.",
     businessInputSchema: {
         type: "object",
         properties: {
@@ -68,5 +69,5 @@ export const autopilotGenerateSpec = {
     },
     requiresProlog: false,
     effects: ["workspace-read"],
-    execute: executeAutopilotGenerate,
+    execute: executePlanBootstrap,
 };

package/dist/public/operations/specs/check-rules.generated.d.ts

@@ -0,0 +1,5 @@
+/** Every selectable kb_check rule name, registry order. */
+export declare const SELECTABLE_RULE_NAMES: readonly string[];
+/** Comma-separated "Allowed:" fragment for the kb_check rules description. */
+export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness";
+//# sourceMappingURL=check-rules.generated.d.ts.map

package/dist/public/operations/specs/check-rules.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAoBlD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,wYACkW,CAAC"}

package/dist/public/operations/specs/check-rules.generated.js

@@ -0,0 +1,34 @@
+/*
+ * Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ * Copyright (C) 2026 Piotr Franczyk
+ *
+ * This file is generated by scripts/generate-rule-registry.mjs from
+ * packages/core/schema/rule-registry.json. Do not edit it directly; edit the
+ * JSON source and regenerate.
+ */
+// implements REQ-006
+/** Every selectable kb_check rule name, registry order. */
+export const SELECTABLE_RULE_NAMES = [
+    "must-priority-coverage",
+    "symbol-coverage",
+    "symbol-traceability",
+    "no-dangling-refs",
+    "source-relationship-parity",
+    "no-cycles",
+    "required-fields",
+    "deprecated-adr-no-successor",
+    "domain-contradictions",
+    "logic-coverage",
+    "rule-safety",
+    "rule-verifiability",
+    "query-plan-safety",
+    "req-status-vocabulary",
+    "strict-fact-shape",
+    "strict-req-fact-pairing",
+    "predicate-verifiability",
+    "strict-readiness",
+    "semantic-completeness",
+];
+// implements REQ-006
+/** Comma-separated "Allowed:" fragment for the kb_check rules description. */
+export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness";

package/dist/public/operations/specs/check.d.ts

@@ -2,7 +2,7 @@ import { executeCheck } from "../check-executor.js";
 export declare const checkSpec: {
     readonly name: "kb_check";
     readonly cliName: "check";
-    readonly 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, including telemetry acceptance when .kb/usage.log exists.";
+    readonly description: "Run KB validation rules and return violations, quality diagnostics, and typed kibi.migration-plan.v2 actions. Use before or after mutations and after source edits; checks remain read-only and never infer or apply actions from prose suggestions.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -10,9 +10,9 @@ export declare const checkSpec: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
-                    readonly enum: readonly ["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", "logic-coverage", "rule-safety", "rule-verifiability", "semantic-completeness", "query-plan-safety"];
+                    readonly enum: readonly string[];
                 };
-                readonly 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, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; if supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";
@@ -40,7 +40,12 @@ export declare const checkSpec: {
             };
             readonly workspaceRoot: {
                 readonly type: "string";
-                readonly description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.";
+                readonly description: "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.";
+            };
+            readonly async: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.";
             };
         };
     };

package/dist/public/operations/specs/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEY,CAAC"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DY,CAAC"}

package/dist/public/operations/specs/check.js

@@ -1,8 +1,9 @@
 import { executeCheck } from "../check-executor.js";
+import { SELECTABLE_RULES_ALLOWED, SELECTABLE_RULE_NAMES, } from "./check-rules.generated.js";
 export const checkSpec = {
     name: "kb_check",
     cliName: "check",
-    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, including telemetry acceptance when .kb/usage.log exists.",
+    description: "Run KB validation rules and return violations, quality diagnostics, and typed kibi.migration-plan.v2 actions. Use before or after mutations and after source edits; checks remain read-only and never infer or apply actions from prose suggestions.",
     businessInputSchema: {
         type: "object",
         properties: {
@@ -10,26 +11,9 @@ export const checkSpec = {
                 type: "array",
                 items: {
                     type: "string",
-                    enum: [
-                        "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",
-                        "logic-coverage",
-                        "rule-safety",
-                        "rule-verifiability",
-                        "semantic-completeness",
-                        "query-plan-safety",
-                    ],
+                    enum: [...SELECTABLE_RULE_NAMES],
                 },
-                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, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; if supplied, server preserves scoped validation and skips the full-KB advisory scan.",
+                description: `Optional rule subset. Allowed: ${SELECTABLE_RULES_ALLOWED}. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.`,
             },
             sourceFiles: {
                 type: "array",
@@ -55,7 +39,12 @@ export const checkSpec = {
             },
             workspaceRoot: {
                 type: "string",
-                description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.",
+                description: "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.",
+            },
+            async: {
+                type: "boolean",
+                default: false,
+                description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.",
             },
         },
     },

package/dist/public/operations/specs/discovery.d.ts

@@ -45,7 +45,7 @@ export declare const querySpec: {
 export declare const searchSpec: {
     readonly name: "kb_search";
     readonly cliName: "search";
-    readonly description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
+    readonly description: "Search KB entities for discovery using legacy lexical ranking or deterministic intent-v1 ranking. Intent mode accepts host-agent semantic facets and source locations, returns evidence and abstains below its confidence threshold. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
@@ -73,6 +73,90 @@ export declare const searchSpec: {
                 readonly default: 0;
                 readonly description: "Optional zero-based pagination offset. Default: 0.";
             };
+            readonly rankingMode: {
+                readonly type: "string";
+                readonly enum: readonly ["legacy", "intent-v1"];
+                readonly default: "legacy";
+                readonly description: "Optional deterministic ranking mode. Omit for backward-compatible lexical search; use intent-v1 for semantic facets, source-aware evidence, graph boosts, and abstention.";
+            };
+            readonly semanticFacets: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly actors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly actions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly objects: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly constraints: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                };
+                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.";
+            };
+            readonly sourceLocations: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["path"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "Workspace-relative source path.";
+                        };
+                        readonly line: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly column: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly symbol: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Optional changed-code locations. Results are matched to source-linked symbols/entities and include source evidence.";
+            };
+            readonly minScore: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly default: 0.18;
+                readonly description: "Intent-v1 acceptance threshold between 0 and 1. Low-confidence queries abstain instead of returning misleading matches.";
+            };
         };
     };
     readonly requiresProlog: true;
@@ -82,12 +166,12 @@ export declare const searchSpec: {
 export declare const statusSpec: {
     readonly name: "kb_status";
     readonly cliName: "status";
-    readonly description: "Report current branch, KB snapshot and freshness metadata, plus the deterministic workspace snapshot used to validate execution receipts. Read-only status inspection with no mutation side effects.";
+    readonly description: "Report current branch, KB snapshot, freshness metadata, schema status, and a typed kibi.migration-plan.v2 action graph. Read-only status inspection with no mutation side effects; damaged stores are diagnosed without starting the engine.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {};
     };
-    readonly requiresProlog: true;
+    readonly requiresProlog: false;
     readonly effects: readonly ["kb-read", "workspace-read"];
     readonly execute: typeof executeStatus;
 };

package/dist/public/operations/specs/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;CASuC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;CAUuC,CAAC"}

package/dist/public/operations/specs/discovery.js

@@ -53,7 +53,7 @@ export const querySpec = {
 export const searchSpec = {
     name: "kb_search",
     cliName: "search",
-    description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.",
+    description: "Search KB entities for discovery using legacy lexical ranking or deterministic intent-v1 ranking. Intent mode accepts host-agent semantic facets and source locations, returns evidence and abstains below its confidence threshold. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         required: ["query"],
@@ -81,6 +81,55 @@ export const searchSpec = {
                 default: 0,
                 description: "Optional zero-based pagination offset. Default: 0.",
             },
+            rankingMode: {
+                type: "string",
+                enum: ["legacy", "intent-v1"],
+                default: "legacy",
+                description: "Optional deterministic ranking mode. Omit for backward-compatible lexical search; use intent-v1 for semantic facets, source-aware evidence, graph boosts, and abstention.",
+            },
+            semanticFacets: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    actors: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    actions: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    objects: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    constraints: {
+                        type: "array",
+                        items: { type: "string" },
+                        maxItems: 20,
+                    },
+                    aliases: { type: "array", items: { type: "string" }, maxItems: 20 },
+                },
+                description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.",
+            },
+            sourceLocations: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["path"],
+                    additionalProperties: false,
+                    properties: {
+                        path: {
+                            type: "string",
+                            minLength: 1,
+                            description: "Workspace-relative source path.",
+                        },
+                        line: { type: "integer", minimum: 1 },
+                        column: { type: "integer", minimum: 1 },
+                        symbol: { type: "string", minLength: 1 },
+                    },
+                },
+                description: "Optional changed-code locations. Results are matched to source-linked symbols/entities and include source evidence.",
+            },
+            minScore: {
+                type: "number",
+                minimum: 0,
+                maximum: 1,
+                default: 0.18,
+                description: "Intent-v1 acceptance threshold between 0 and 1. Low-confidence queries abstain instead of returning misleading matches.",
+            },
         },
     },
     requiresProlog: true,
@@ -90,9 +139,10 @@ export const searchSpec = {
 export const statusSpec = {
     name: "kb_status",
     cliName: "status",
-    description: "Report current branch, KB snapshot and freshness metadata, plus the deterministic workspace snapshot used to validate execution receipts. Read-only status inspection with no mutation side effects.",
+    description: "Report current branch, KB snapshot, freshness metadata, schema status, and a typed kibi.migration-plan.v2 action graph. Read-only status inspection with no mutation side effects; damaged stores are diagnosed without starting the engine.",
     businessInputSchema: { type: "object", properties: {} },
-    requiresProlog: true,
+    // Status must remain available when the branch store cannot be attached.
+    requiresProlog: false,
     effects: ["kb-read", "workspace-read"],
     execute: executeStatus,
 };

package/dist/public/operations/specs/modeling.d.ts

@@ -14,7 +14,7 @@ export declare const modelRequirementSpec: {
             };
             readonly source: {
                 readonly type: "string";
-                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.";
+                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: '.kb/requirements/customer-retention.md'.";
             };
             readonly sourceFiles: {
                 readonly type: "array";
@@ -48,7 +48,7 @@ export declare const modelRequirementSpec: {
             };
             readonly provenance: {
                 readonly type: "string";
-                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.";
+                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: '.kb/requirements/customer-retention.md#L1'.";
             };
             readonly existingLogicClaims: {
                 readonly type: "array";
@@ -84,7 +84,7 @@ export declare const modelRequirementSpec: {
 export declare const suggestPredicatesSpec: {
     readonly name: "kb_suggest_predicates";
     readonly cliName: "suggest-predicates";
-    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, an applicable predicate-fact plan only when every ordered argument is bound, a separate requires_predicate relationship plan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
+    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Retrieval/ranking is followed by a semantic applicability gate and conservative binding review; complete-looking generic placeholders never trigger application. Read-only guidance returns additive candidate diagnostics, an applicable predicate-fact plan only for a semantically eligible candidate with reviewed bindings, or an explicit ontology-gap observation plus a deterministic review-only predicate schema draft when no schema fits.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["text"];

package/dist/public/operations/specs/modeling.js

@@ -14,7 +14,7 @@ export const modelRequirementSpec = {
             },
             source: {
                 type: "string",
-                description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.",
+                description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: '.kb/requirements/customer-retention.md'.",
             },
             sourceFiles: {
                 type: "array",
@@ -46,7 +46,7 @@ export const modelRequirementSpec = {
             },
             provenance: {
                 type: "string",
-                description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.",
+                description: "Optional extracted text reference. Falls back to source when omitted. Example: '.kb/requirements/customer-retention.md#L1'.",
             },
             existingLogicClaims: {
                 type: "array",
@@ -79,7 +79,7 @@ export const modelRequirementSpec = {
 export const suggestPredicatesSpec = {
     name: "kb_suggest_predicates",
     cliName: "suggest-predicates",
-    description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, an applicable predicate-fact plan only when every ordered argument is bound, a separate requires_predicate relationship plan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.",
+    description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Retrieval/ranking is followed by a semantic applicability gate and conservative binding review; complete-looking generic placeholders never trigger application. Read-only guidance returns additive candidate diagnostics, an applicable predicate-fact plan only for a semantically eligible candidate with reviewed bindings, or an explicit ontology-gap observation plus a deterministic review-only predicate schema draft when no schema fits.",
     businessInputSchema: {
         type: "object",
         required: ["text"],