kibi-cli 2.6.0 → 2.7.0

package/dist/public/skills/kibi-usage/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.3.1
+version: 2.4.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -154,11 +154,43 @@ execute each required repair action in order, and never retry the original
 operation. Record effect failures, followed actions, and unsafe retries in
 diagnostic telemetry.
 
+## Entity body contract
+
+The body is where context lives; front matter is the checked meaning.
+`kb_check` rule `entity-context-missing` blocks a current `req`, `scenario`,
+`test`, `adr` or observation/meta `fact` whose body carries no context: at
+least 12 words that are not a restatement of the title (for a requirement, also
+not of `semantic_text`). Symbols, flags, events and every other fact kind are
+exempt. `kb_upsert` returns the same finding as a warning, including on dryRun.
+
+- `req`: the statement, then `## Context` (why, who asked, constraints) and
+  `## Source` (blockquoted excerpt plus reference). Only text under context
+  headings (Context, Rationale, Why, Background, Source, Notes, Evidence)
+  counts for a requirement, and it never changes the checked meaning:
+  `semantic_text` is written explicitly and context sections are excluded.
+- `scenario`: Given/When/Then prose plus the assumptions it depends on.
+- `test`: what it asserts, how (fixture, entry point), what would make it a
+  false pass.
+- `fact` (`observation`/`meta`): what was seen, where, when, how confirmed.
+- Never invent a reason the requester did not give. Write "Reason not stated"
+  and the source instead.
+- The tag `review:context-missing` is reserved for entities the schema 8
+  migration (`kibi migrate`) acknowledged and recorded in the manifest; it is
+  counted by the advisory `entity-context-acknowledged`. Never add it yourself:
+  on any other entity it is still a violation. Write who asked, the source and
+  "Reason not stated" in the Context section instead.
+- `kb_plan_compile_intent` requires `context` when the plan creates a
+  requirement, and accepts `sourceExcerpt` and `sourceReference`. On update it
+  rewrites the statement and keeps the existing context sections unless you
+  supply new `context` or source.
+
 ## Source-first mutation
 
 Use `document.path` when a new entity has no single configured writable target.
-Existing entities preserve body bytes when `document.body` is omitted; new
-requirements default their body to `semantic_text`. Relationship mutations
+Existing entities preserve body bytes when `document.body` is omitted; a new
+requirement without `document.body` gets `semantic_text` as its body, and
+`kb_check` then blocks it with `entity-context-missing`, so always pass a
+sectioned `document.body` (see Entity body contract). Relationship mutations
 patch canonical shards while preserving unrelated records. Authored entity
 deletion returns a hash-bound approval plan; requirements normally evolve via a
 new entity linked with `supersedes`; set the replaced requirement to
@@ -220,6 +252,27 @@ grounding: run `logic-coverage` so each key binds to one ground fact.
 Relationship direction is fixed, and every `from` in a relationship batch
 must equal the upserted entity ID.
 
+Worked example. `recommendedAction: "provide_argument_bindings"` means a
+schema fits but `unbound_arguments` lists roles Kibi could not read from the
+prose. Bind them from the claim's own words and call again with the same
+`text` and `requirementId`, plus `schemaId` and `argumentBindings` keyed by
+`argument_names` (reuse `argument_constants` values when the schema has them):
+
+```json
+{"mode":"predicates","text":"Only an annotation owner may delete an annotation.","requirementId":"REQ-annotation-delete-owner","schemaId":"FACT-SCHEMA-PERMISSION-RULE","argumentBindings":{"actor":"annotation_owner","action":"delete","resource":"annotation","decision":"allow"}}
+```
+
+When the retry returns `apply_requires_predicate`, write its `applyPlan` fact,
+then the `relationshipPlan` `requires_predicate` row. Record an ontology gap
+only when no returned schema fits the claim, not because bindings were missing.
+A review note is an observation that quotes its claim without `claim_key`:
+`{"type":"fact","id":"FACT-review-<area>-<behavior>","properties":{"title":"Review: ...","status":"active","fact_kind":"observation","text_ref":"<sourceId>:<reference>","tags":["review:invalid-write"],"claim_text":"<the claim>"}}`.
+
+To add `specified_by` (or another relationship) to an existing requirement,
+upsert it with its stored `title`, a `status` and the relationship only; Kibi
+keeps the stored proposition ledger when no `semantic_*` or `logic_claims`
+field is sent and `title`/`text_ref` are unchanged.
+
 For conditional relational claims, after the initial `kb_model` predicates call and before any `kb_upsert`—including one needed for a missing schema—call read-only `kb_model` with `mode: "requirement"` to preview suitable scalar or typed-rule modeling. Treat the preview as advisory: do not apply an irrelevant result or create unrequested facts, and retain an approved ground-predicate plan when it captures the whole claim. Preserve supplied arity, ordered argument roles, polarity, bound values, and one claim key per actual assertion; never split arguments across clauses or schemas or alter values to force uniqueness.
 
 ## Symbol-First Traceability

package/dist/public/skills/kibi-usage/resources/source-authoring.md

@@ -7,7 +7,11 @@ commits them; ordinary Git workflows remain responsible for review and merge.
 
 `kb_upsert` accepts `document.path` and `document.body`. Existing entities use
 their authored source by default and preserve body bytes when `body` is omitted.
-New requirements use `semantic_text` as their body. If a new entity has zero or
+A new requirement without `body` uses `semantic_text` as its body, which
+`entity-context-missing` blocks; pass a sectioned body (statement, `## Context`,
+`## Source`) and the written `semantic_text` stays the checked meaning, since
+context sections are excluded from it. Source-first requirement writes pin
+`semantic_text` in front matter. If a new entity has zero or
 multiple configured writable targets, provide an explicit workspace-relative
 `document.path`; absolute, traversal, and symlink escapes are rejected.
 

package/dist/schemas/entity.schema.json

@@ -1684,7 +1684,20 @@
                     {
                         "required": [
                             "claim_text"
-                        ]
+                        ],
+                        "not": {
+                            "properties": {
+                                "fact_kind": {
+                                    "enum": [
+                                        "observation",
+                                        "meta"
+                                    ]
+                                }
+                            },
+                            "required": [
+                                "fact_kind"
+                            ]
+                        }
                     }
                 ]
             },

package/dist/search-ranking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-ranking.d.ts","sourceRoot":"","sources":["../src/search-ranking.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAgDD,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,WAAW,EAAE,CAAC,CA8BxB;AAsGD,wBAAsB,gBAAgB,CAEpC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA6BxB;AAuJD,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,GAAG,SAAS,CAQpB"}
+{"version":3,"file":"search-ranking.d.ts","sourceRoot":"","sources":["../src/search-ranking.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAgDD,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,WAAW,EAAE,CAAC,CA8BxB;AAsGD,wBAAsB,gBAAgB,CAEpC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA6BxB;AA0JD,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,GAAG,SAAS,CAQpB"}

package/dist/search-ranking.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { bodySnippetLine } from "./entity-body-context.js";
 const SEARCH_STOP_WORDS = new Set([
     "to",
     "in",
@@ -115,14 +116,14 @@ async function rankEntity(entity, queryContext, workspaceRoot) {
         if (isPhraseSearchMatch(bodyForms, queryContext.phrase)) {
             score += 15;
             reasons.push("markdown body match");
-            snippet = buildSnippet(bodyText, queryContext.phrase);
+            snippet = buildSnippet(bodyText, queryContext.phrase, entity);
         }
         else {
             const bodyTokenMatches = countTokenMatches(bodyForms, queryContext.signalTokens);
             if (bodyTokenMatches > 0) {
                 score += bodyTokenMatches * 3;
                 reasons.push("markdown body token coverage");
-                snippet = buildSnippet(bodyText, queryContext.phrase);
+                snippet = buildSnippet(bodyText, queryContext.phrase, entity);
             }
         }
     }
@@ -257,12 +258,14 @@ function getInlineBodyText(entity) {
     return null;
 }
 // implements REQ-mcp-search-discovery
-function buildSnippet(bodyText, queryForms) {
+function buildSnippet(bodyText, queryForms, entity) {
     const lines = bodyText
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter(Boolean);
-    const matchedLine = lines.find((line) => isPhraseSearchMatch(buildSearchTextForms(line), queryForms)) ?? lines[0];
+    // The line that matches the query wins; otherwise the context prose, then
+    // the first line.
+    const matchedLine = lines.find((line) => isPhraseSearchMatch(buildSearchTextForms(line), queryForms)) ?? bodySnippetLine(String(entity.type ?? ""), bodyText, entity);
     return snippetFromMatchedLine(matchedLine);
 }
 export function snippetFromMatchedLine(matchedLine) {

package/dist/traceability/staged-consistency.d.ts

@@ -0,0 +1,25 @@
+import type { ExtractionResult } from "../extractors/markdown.js";
+import type { Violation } from "../public/check-types.js";
+type SnapshotReader = Readonly<{
+    baseTree: string;
+    headTree: string;
+    readGit(args: readonly string[]): Buffer;
+    readBlobs(oids: readonly string[]): ReadonlyMap<string, Buffer>;
+}>;
+/**
+ * True when the staged change set touches entity documents or relationship
+ * shards, the only knowledge these rules read. A symbols manifest change
+ * alone cannot change their outcome.
+ */
+export declare function stagesKnowledge(paths: readonly string[]): boolean;
+/**
+ * Consistency violations the staged tree has and the base tree does not.
+ * A violation already present at the base commit does not block an
+ * unrelated commit; full `kibi check` still reports it. The base tree is
+ * only analyzed when the staged tree has violations.
+ */
+export declare function collectIntroducedConsistencyViolations(snapshot: SnapshotReader, headKnowledge: ExtractionResult[]): Promise<Violation[]>;
+/** Text lines for introduced consistency violations, in `kibi check` form. */
+export declare function formatConsistencyViolations(violations: readonly Violation[]): string[];
+export {};
+//# sourceMappingURL=staged-consistency.d.ts.map

package/dist/traceability/staged-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-consistency.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-consistency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAsB1D,KAAK,cAAc,GAAG,QAAQ,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACzC,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjE,CAAC,CAAC;AAEH;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAMjE;AAkDD;;;;;GAKG;AAEH,wBAAsB,sCAAsC,CAC1D,QAAQ,EAAE,cAAc,EACxB,aAAa,EAAE,gBAAgB,EAAE,GAChC,OAAO,CAAC,SAAS,EAAE,CAAC,CAYtB;AAED,8EAA8E;AAE9E,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,SAAS,SAAS,EAAE,GAC/B,MAAM,EAAE,CAWV"}

package/dist/traceability/staged-consistency.js

@@ -0,0 +1,92 @@
+import { runAggregatedChecks } from "../commands/aggregated-checks.js";
+import { isEntityLanePath } from "../utils/kb-paths.js";
+import { readSnapshotKnowledge } from "./snapshot-knowledge.js";
+import { cleanupTempKb, createTempKb, projectStagedEntities, } from "./temp-kb.js";
+/**
+ * Canonical rules that decide whether the staged knowledge is consistent:
+ * requirement contradictions, success scenarios a current requirement
+ * forbids, and exceptions that name claims they cannot waive. They read only
+ * authored knowledge, so the staged tree alone decides them.
+ */
+// implements REQ-cli-staged-consistency
+const STAGED_CONSISTENCY_RULES = [
+    "domain-contradictions",
+    "scenario-feasibility",
+    "exception-claim-keys",
+];
+/**
+ * True when the staged change set touches entity documents or relationship
+ * shards, the only knowledge these rules read. A symbols manifest change
+ * alone cannot change their outcome.
+ */
+// implements REQ-cli-staged-consistency
+export function stagesKnowledge(paths) {
+    return paths.some((file) => (isEntityLanePath(file) && file.endsWith(".md")) ||
+        (file.startsWith(".kb/relationships/") && /\.ya?ml$/.test(file)));
+}
+// implements REQ-cli-staged-consistency
+function violationKey(violation) {
+    return JSON.stringify([
+        violation.rule,
+        violation.entityId,
+        violation.description,
+    ]);
+}
+/**
+ * The knowledge these rules read: every entity except code symbols, and the
+ * relationships between them. Symbols and their edges are most of a large
+ * KB and would dominate the projection time of a pre-commit hook.
+ */
+// implements REQ-cli-staged-consistency
+function withoutSymbols(knowledge) {
+    const ids = new Set(knowledge
+        .filter(({ entity }) => entity.type !== "symbol")
+        .map(({ entity }) => entity.id));
+    return knowledge
+        .filter(({ entity }) => ids.has(entity.id))
+        .map((result) => ({
+        ...result,
+        relationships: result.relationships.filter((relationship) => ids.has(relationship.from) && ids.has(relationship.to)),
+    }));
+}
+// implements REQ-cli-staged-consistency
+async function consistencyViolations(knowledge) {
+    const ctx = await createTempKb();
+    try {
+        await projectStagedEntities(ctx.prolog, withoutSymbols(knowledge));
+        return await runAggregatedChecks(ctx.prolog, new Set(STAGED_CONSISTENCY_RULES));
+    }
+    finally {
+        await cleanupTempKb(ctx.tempDir);
+    }
+}
+/**
+ * Consistency violations the staged tree has and the base tree does not.
+ * A violation already present at the base commit does not block an
+ * unrelated commit; full `kibi check` still reports it. The base tree is
+ * only analyzed when the staged tree has violations.
+ */
+// implements REQ-cli-staged-consistency
+export async function collectIntroducedConsistencyViolations(snapshot, headKnowledge) {
+    const head = await consistencyViolations(headKnowledge);
+    if (head.length === 0)
+        return [];
+    const base = await consistencyViolations(readSnapshotKnowledge(snapshot.readGit, snapshot.baseTree, snapshot.readBlobs));
+    const existing = new Set(base.map(violationKey));
+    return head.filter((violation) => !existing.has(violationKey(violation)));
+}
+/** Text lines for introduced consistency violations, in `kibi check` form. */
+// implements REQ-cli-staged-consistency
+export function formatConsistencyViolations(violations) {
+    const lines = [
+        `Found ${violations.length} consistency violation(s) introduced by the staged changes:`,
+        "",
+    ];
+    for (const violation of violations) {
+        lines.push(`[${violation.rule}] ${violation.entityId}`);
+        if (violation.source)
+            lines.push(`  Source: ${violation.source}`);
+        lines.push(`  ${violation.description}`, "");
+    }
+    return lines;
+}

package/dist/traceability/temp-kb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"temp-kb.d.ts","sourceRoot":"","sources":["../../src/traceability/temp-kb.ts"],"names":[],"mappings":"AAMA,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAET;AACD,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB;AAMD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CASvC;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAE/B,OAAO,EAAE,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,CAAA;CAAE,KAAK,aAAa,GACpE,IAAI,CAEN;AAyRD,iBAAe,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAe1B,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CA4Df;AAED,wBAAsB,YAAY,CAChC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,CAAC,CA+CxB;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBrE;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE"}
+{"version":3,"file":"temp-kb.d.ts","sourceRoot":"","sources":["../../src/traceability/temp-kb.ts"],"names":[],"mappings":"AAMA,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAET;AACD,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB;AAMD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CASvC;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAE/B,OAAO,EAAE,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,CAAA;CAAE,KAAK,aAAa,GACpE,IAAI,CAEN;AA8RD,iBAAe,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAe1B,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CA4Df;AAED,wBAAsB,YAAY,CAChC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,CAAC,CA+CxB;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBrE;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE"}

package/dist/traceability/temp-kb.js

@@ -194,6 +194,11 @@ function buildEntityAssertionGoal(entity, sourceFile) {
     if (entity.type === "req" && entity.exempts_claims) {
         props.push(`exempts_claims=[${entity.exempts_claims.map(toPrologAtom).join(",")}]`);
     }
+    // implements REQ-cli-staged-consistency
+    // Scenario feasibility reads the intended outcome.
+    if (entity.type === "scenario" && entity.expects !== undefined) {
+        props.push(`expects=${toPrologAtom(entity.expects)}`);
+    }
     if (entity.origin !== undefined) {
         props.push(`origin=${toPrologString(JSON.stringify(entity.origin))}`);
     }

package/dist/utils/kb-manifest.d.ts

@@ -15,6 +15,11 @@ export interface KbManifest {
     schemaVersion: number;
     /** Retroactive semantic-advisor backfill review state. */
     semanticAdvisorBackfill: SemanticAdvisorBackfill;
+    /**
+     * Entity ids the schema 8 migration acknowledged as lacking body context.
+     * Only these ids may carry `review:context-missing` without a violation.
+     */
+    contextAcknowledged?: string[];
 }
 export declare function defaultKbManifest(): KbManifest;
 export type KbManifestStatus = {

package/dist/utils/kb-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kb-manifest.d.ts","sourceRoot":"","sources":["../../src/utils/kb-manifest.ts"],"names":[],"mappings":"AA8BA;;;;;;;GAOG;AAEH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,MAAM,MAAM,uBAAuB,GAC/B,SAAS,GACT,WAAW,GACX,gBAAgB,CAAC;AAErB,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,eAAe,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,uBAAuB,EAAE,uBAAuB,CAAC;CAClD;AAED,wBAAgB,iBAAiB,IAAI,UAAU,CAM9C;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAClE;IACE,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,QAAQ,EAAE,IAAI,CAAC;IACf,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA+CN,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CAyD5E;AAED,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAGvE;AAED,8EAA8E;AAC9E,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,UAAU,CAEzE;AASD,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAIR"}
+{"version":3,"file":"kb-manifest.d.ts","sourceRoot":"","sources":["../../src/utils/kb-manifest.ts"],"names":[],"mappings":"AA8BA;;;;;;;GAOG;AAEH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,MAAM,MAAM,uBAAuB,GAC/B,SAAS,GACT,WAAW,GACX,gBAAgB,CAAC;AAErB,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,eAAe,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,uBAAuB,EAAE,uBAAuB,CAAC;IACjD;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,wBAAgB,iBAAiB,IAAI,UAAU,CAM9C;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAClE;IACE,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,QAAQ,EAAE,IAAI,CAAC;IACf,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAuDN,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CAyD5E;AAED,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAGvE;AAED,8EAA8E;AAC9E,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,UAAU,CAEzE;AASD,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAIR"}

package/dist/utils/kb-manifest.js

@@ -70,10 +70,16 @@ function validateManifest(parsed) {
         backfill !== "not_applicable") {
         return null;
     }
+    const acknowledged = parsed.contextAcknowledged;
     return {
         manifestVersion,
         schemaVersion,
         semanticAdvisorBackfill: backfill,
+        ...(Array.isArray(acknowledged)
+            ? {
+                contextAcknowledged: acknowledged.filter((id) => typeof id === "string"),
+            }
+            : {}),
     };
 }
 export function readKbManifestStatus(workspaceRoot) {

package/dist/utils/rule-registry.generated.d.ts

@@ -207,5 +207,16 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "Predicate facts match a predicate_schema (project-local, or the built-in catalog in the default namespace) and use its declared argument constants";
     readonly enforcementClass: "advisory";
     readonly category: "integrity";
+}, {
+    readonly name: "entity-context-missing";
+    readonly description: "A current requirement, scenario, test, ADR or observation/meta fact must carry body context: at least 12 words of prose (requirements: under a Context, Rationale, Why, Background, Source, Notes or Evidence heading) that do not restate the title or semantic_text; entities tagged review:context-missing are acknowledged legacy and exempt";
+    readonly enforcementClass: "canonical";
+    readonly category: "integrity";
+}, {
+    readonly name: "entity-context-acknowledged";
+    readonly description: "Informational: how many current entities carry the review:context-missing tag, so the legacy context backlog stays visible; one summary finding per check";
+    readonly enforcementClass: "advisory";
+    readonly category: "lifecycle";
+    readonly diagnosticSeverity: "info";
 }];
 //# sourceMappingURL=rule-registry.generated.d.ts.map

package/dist/utils/rule-registry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiSlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgTlB,CAAC"}

package/dist/utils/rule-registry.generated.js

@@ -258,4 +258,17 @@ export const GENERATED_RULES = [
         enforcementClass: "advisory",
         category: "integrity",
     },
+    {
+        name: "entity-context-missing",
+        description: "A current requirement, scenario, test, ADR or observation/meta fact must carry body context: at least 12 words of prose (requirements: under a Context, Rationale, Why, Background, Source, Notes or Evidence heading) that do not restate the title or semantic_text; entities tagged review:context-missing are acknowledged legacy and exempt",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
+    {
+        name: "entity-context-acknowledged",
+        description: "Informational: how many current entities carry the review:context-missing tag, so the legacy context backlog stays visible; one summary finding per check",
+        enforcementClass: "advisory",
+        category: "lifecycle",
+        diagnosticSeverity: "info",
+    },
 ];

package/dist/utils/schema-version.d.ts

@@ -1,4 +1,4 @@
-export declare const LATEST_KB_SCHEMA_VERSION = 7;
+export declare const LATEST_KB_SCHEMA_VERSION = 8;
 export interface SchemaVersionStatus {
     status: "missing" | "invalid" | "older" | "current" | "newer";
     currentVersion: number | null;

package/dist/utils/schema-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../src/utils/schema-version.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IAC9D,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,GACrD,IAAI,GACJ,SAAS,CAAC;AAGd,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAChD,MAAM,GAAG,IAAI,CAgBf;AAGD,wBAAgB,sBAAsB,CACpC,MAAM,CAAC,EAAE,mBAAmB,GAC3B,mBAAmB,CAgDrB"}
+{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../src/utils/schema-version.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IAC9D,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,GACrD,IAAI,GACJ,SAAS,CAAC;AAGd,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAChD,MAAM,GAAG,IAAI,CAgBf;AAGD,wBAAgB,sBAAsB,CACpC,MAAM,CAAC,EAAE,mBAAmB,GAC3B,mBAAmB,CAgDrB"}

package/dist/utils/schema-version.js

@@ -16,8 +16,9 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 // implements REQ-003
-// Schema 7 requires strict fact shapes and encodes legacy polarity values.
-export const LATEST_KB_SCHEMA_VERSION = 7;
+// Schema 8 requires body context on current entities and pins requirement
+// semantic_text so context sections never change a requirement's meaning.
+export const LATEST_KB_SCHEMA_VERSION = 8;
 // implements REQ-003
 export function normalizeSchemaVersion(schemaVersion) {
     if (schemaVersion === undefined || schemaVersion === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,7 +235,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.15.1",
+    "kibi-core": "^0.16.0",
     "kibi-plugin-builtin": "^0.4.2",
     "kibi-plugin-sdk": "^0.4.1",
     "kibi-swipl": "^1.0.1",

package/schema/manifest.json

@@ -21,6 +21,11 @@
       "type": "string",
       "enum": ["pending", "completed", "not_applicable"],
       "description": "Retroactive semantic-advisor backfill review state"
+    },
+    "contextAcknowledged": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Entity ids the schema 8 migration acknowledged as lacking body context; only these may carry review:context-missing without an entity-context-missing violation"
     }
   }
 }

package/schema/validation.pl

@@ -225,15 +225,27 @@ valid_strict_polarity_in_props(Props) :-
 valid_predicate_polarity_in_props(Props) :-
     ( memberchk(polarity=P, Props) -> valid_predicate_polarity(P) ; true ).
 
-% claim_key and claim_text form one auditable provenance pair.
+% claim_key and claim_text form one auditable provenance pair. An observation
+% or meta fact is a non-grounding review note: it may quote the claim it is
+% about in claim_text without claiming that claim's key.
 valid_claim_provenance(Props) :-
     (   memberchk(claim_key=Key, Props)
     ->  memberchk(claim_text=Text, Props),
         nonempty_claim_value(Key),
         nonempty_claim_value(Text)
-    ;   \+ memberchk(claim_text=_, Props)
+    ;   memberchk(claim_text=Text, Props)
+    ->  review_note_fact(Props),
+        nonempty_claim_value(Text)
+    ;   true
     ).
 
+review_note_fact(Props) :-
+    memberchk(fact_kind=RawKind, Props),
+    (   atom(RawKind) -> Kind = RawKind
+    ;   string(RawKind) -> atom_string(Kind, RawKind)
+    ),
+    memberchk(Kind, [observation, meta]).
+
 nonempty_claim_value(Value) :- string(Value), Value \= "", !.
 nonempty_claim_value(Value) :- atom(Value), Value \= '', !.
 

package/src/public/operations/check-executor.ts

@@ -34,6 +34,7 @@ import {
   stagedEntityIdStyleDiagnostics,
 } from "./check-helpers.js";
 import { executeStatus } from "./discovery-executors.js";
+import { collectEntityContextViolations } from "./entity-context.js";
 import {
   buildActionsFromCheck,
   buildMigrationPlan,
@@ -224,6 +225,10 @@ export async function executeCheck(
       rulesAllowlist,
       workspaceRoot,
     );
+    const entityContextFindings = collectEntityContextViolations(
+      rulesAllowlist,
+      workspaceRoot,
+    );
     const partitioned = partitionCheckFindings([
       ...aggregatedFindings,
       ...queryPlanViolations,
@@ -231,6 +236,7 @@ export async function executeCheck(
       ...sourcePathFindings,
       ...predicateConformanceFindings,
       ...originReviewFindings,
+      ...entityContextFindings,
     ]);
     const violations: Violation[] = partitioned.violations;