kibi-cli 2.5.2 → 2.6.1

package/dist/operations/semantic-advisor/analyze-prose.d.ts

@@ -1,7 +1,8 @@
-import type { SemanticAdvisorAnalysisResult, SemanticAdvisorInput, SemanticPropositionRole } from "./types.js";
+import { propositionRole } from "./proposition-role.js";
+import type { SemanticAdvisorAnalysisResult, SemanticAdvisorInput } from "./types.js";
 export declare const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v2";
 export { semanticClaimKey } from "./clauses.js";
 export declare function stringLogicClaims(value: unknown): string[];
-export declare function propositionRole(statement: string, normative: boolean): SemanticPropositionRole;
+export { propositionRole };
 export declare function analyzeSemanticAdvisorInput(input: SemanticAdvisorInput): SemanticAdvisorAnalysisResult;
 //# sourceMappingURL=analyze-prose.d.ts.map

package/dist/operations/semantic-advisor/analyze-prose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze-prose.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analyze-prose.ts"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAKpB,uBAAuB,EAMxB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAI1D;AAwgBD,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,GACjB,uBAAuB,CAuDzB;AA4VD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CA+D/B"}
+{"version":3,"file":"analyze-prose.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analyze-prose.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAiBxD,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAWrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAI1D;AAugBD,OAAO,EAAE,eAAe,EAAE,CAAC;AA4V3B,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CA+D/B"}

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

@@ -2,9 +2,10 @@ import { createBuiltinOntologyPack, detectSignals as detectBuiltinSignals, } fro
 import { utf8Span, validateLogicIr, } from "../../logic/ir.js";
 import { logicRuleFactId } from "../modeling/logic-modeling.js";
 import { buildAdvisorResult } from "./analysis-receipt.js";
-import { extractSemanticClauses, hasNormativeAssertion, semanticClaimKey, } from "./clauses.js";
+import { extractSemanticClauses, semanticClaimKey, } from "./clauses.js";
 import { detectConditionalRule, } from "./conditional-rules.js";
 import { observationPlan } from "./observation-plan.js";
+import { propositionRole } from "./proposition-role.js";
 import { predicateSuggestion as buildPredicateSuggestion, isRecord, payloadHash, propertiesOf, relationship, semanticClausesOf, semanticSourceHash, semanticSourceOf, sourceOf, statementOf, stringValue, } from "./shared.js";
 import { detectStrictSuggestion } from "./strict-rules.js";
 export const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v2";
@@ -415,46 +416,7 @@ function unmatchedClauseSuggestion(payload, clause, clauses, expectedClaimKeys)
         ]),
     }, clause, clauses, expectedClaimKeys, statementOf(payload), semanticSourceOf(payload).field);
 }
-// implements REQ-kibi-conditional-requirement-authoring
-export function propositionRole(statement, normative) {
-    // Explicit context labels may quote obligations. Incidental explanatory
-    // words within an asserted obligation must not exempt it from grounding.
-    const assertedNormative = normative && hasNormativeAssertion(statement);
-    // A bare desired impression is subjective, even when phrased with should.
-    // Keep concrete actions, quantitative conditions and any independent
-    // obligation assertive instead of exempting them through subjective words.
-    const impression = /\bshould\s+(?:feel\s+(?:welcoming|comfortable|energetic)(?:\s+and\s+(?:welcoming|comfortable|energetic))*|(?:look|seem)\s+complete)\b/i.exec(statement);
-    const impressionTail = impression
-        ? statement.slice(impression.index + impression[0].length).trim()
-        : "";
-    const subjectiveAspiration = impression !== null &&
-        (impressionTail.length === 0 ||
-            /^(?:to|for)\s+[^,;.!?]+$/i.test(impressionTail)) &&
-        !/\b(?:and|or)\b/i.test(impressionTail) &&
-        !/\d|\b(?:at least|at most|exactly|within|no more than)\b/i.test(statement) &&
-        !hasNormativeAssertion(statement.replace(impression[0], ""));
-    if (/^\s*(?:for example\b|e\.g\.|(?:example|illustrative(?: example)?)\s*:)/i.test(statement) ||
-        (!assertedNormative &&
-            /\b(?:for example|e\.g\.|such as|illustrative)\b/i.test(statement)))
-        return "example";
-    if (/^\s*rationale\s*:/i.test(statement) ||
-        (!assertedNormative &&
-            /\b(?:because|so that|in order to| rationale|therefore)\b/i.test(statement)))
-        return "rationale";
-    if (subjectiveAspiration ||
-        (!assertedNormative &&
-            /\b(?:feel|comfortable|looks complete|seems complete|subjective|prefer)\b/i.test(statement)))
-        return "subjective";
-    if (/\b(?:means|defined as|refers to|is called)\b/i.test(statement))
-        return "definition";
-    if (/^\s*(?:if|when|whenever|provided that|only if)\b/i.test(statement))
-        return "condition";
-    if (/\b(?:unless|except|exempt|apart from)\b/i.test(statement))
-        return "exception";
-    if (normative)
-        return "normative";
-    return "descriptive";
-}
+export { propositionRole };
 function shadowAnalysis(text, interpretations) {
     const valid = interpretations.filter((interpretation) => interpretation.valid);
     const models = valid.flatMap(({ normalized_ir: ir }) => (ir ? [ir] : []));

package/dist/operations/semantic-advisor/ingestion-boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ingestion-boundary.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/ingestion-boundary.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E,OAAO,EACL,KAAK,OAAO,EAOb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,sBAAsB,EAAuB,MAAM,YAAY,CAAC;AAgB9E,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,EAAE,CAAC,EAAE,OAAO,CAAC;CACd,CAAC,CAAC;AAgCH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,sBAAsB,GAC9B,+BAA+B,CA0IjC;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAWN;AAoDD;;;;GAIG;AAEH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAC9D,MAAM,GAAG,IAAI,CAUf;AAGD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,MAAM,CAAC,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAClE,CAAC,GACD,OAAO,CAAC,IAAI,CAAC,CAwBf"}
+{"version":3,"file":"ingestion-boundary.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/ingestion-boundary.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAG3E,OAAO,EACL,KAAK,OAAO,EAOb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,sBAAsB,EAAuB,MAAM,YAAY,CAAC;AAgB9E,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,EAAE,CAAC,EAAE,OAAO,CAAC;CACd,CAAC,CAAC;AA+CH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,sBAAsB,GAC9B,+BAA+B,CA0IjC;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAWN;AAoDD;;;;GAIG;AAEH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAC9D,MAAM,GAAG,IAAI,CAUf;AAGD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,MAAM,CAAC,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAClE,CAAC,GACD,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/dist/operations/semantic-advisor/ingestion-boundary.js

@@ -1,5 +1,6 @@
 import { escapeAtom } from "../../prolog/codec.js";
 import { semanticClaimKey } from "./clauses.js";
+import { legacyPropositionRoles } from "./proposition-role.js";
 import { SEMANTIC_INVENTORY_VERSION, isRecord, propertiesOf, semanticSourceHash, semanticSourceOf, stringValue, } from "./shared.js";
 const CURRENT_REQUIREMENT_STATUSES = new Set([
     "open",
@@ -14,6 +15,14 @@ const LOGICAL_RELATIONSHIPS = new Set([
     "requires_predicate",
     "requires_rule",
 ]);
+// A stored role matches when it is the advisor's current role or, for an
+// assertive proposition, a role an earlier advisor assigned to the same text.
+function roleMatchesAdvisor(role, expected) {
+    if (role === expected.role)
+        return true;
+    return (!CONTEXT_ROLES.has(expected.role) &&
+        legacyPropositionRoles(expected.claim_text).includes(role));
+}
 function inventoryOf(payload) {
     const raw = propertiesOf(payload).semantic_inventory;
     return Array.isArray(raw) ? raw.filter(isRecord) : [];
@@ -96,7 +105,7 @@ export function validateSemanticInventoryBoundary(payload, relationships, receip
         if (expected &&
             (claimKey !== expected.claim_key ||
                 claimText !== expected.claim_text ||
-                role !== expected.role ||
+                !roleMatchesAdvisor(role, expected) ||
                 start !== expected.span.start ||
                 end !== expected.span.end)) {
             errors.push(`semantic_inventory[${index}] does not match advisor proposition '${expected.claim_key}'`);

package/dist/operations/semantic-advisor/proposition-role.d.ts

@@ -0,0 +1,6 @@
+import type { SemanticPropositionRole } from "./types.js";
+export declare function isDefinitionShape(statement: string): boolean;
+export declare function legacyPropositionRoles(statement: string): readonly SemanticPropositionRole[];
+export declare function propositionRole(statement: string, normative: boolean): SemanticPropositionRole;
+export declare function advisorPropositionRole(semanticText: string, claimKey: string, suppliedClauses?: readonly string[]): SemanticPropositionRole | null;
+//# sourceMappingURL=proposition-role.d.ts.map

package/dist/operations/semantic-advisor/proposition-role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposition-role.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/proposition-role.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAU1D,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAQ5D;AAOD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,SAAS,uBAAuB,EAAE,CAEpC;AAGD,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,GACjB,uBAAuB,CAqDzB;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAClC,uBAAuB,GAAG,IAAI,CAKhC"}

package/dist/operations/semantic-advisor/proposition-role.js

@@ -0,0 +1,76 @@
+import { extractSemanticClauses, hasNormativeAssertion } from "./clauses.js";
+const DEFINITION_VERB = /\b(?:means|defined as|refers to|is called)\b/i;
+const CONDITION_OPENER = /^\s*(?:if|when|whenever|provided that|only if)\b/i;
+// implements REQ-kibi-conditional-requirement-authoring
+// A definition is "<subject> means|is defined as|refers to|is called <...>" as
+// the main predicate of a sentence that asserts no obligation. A definition
+// verb that opens a relative clause ("every note that refers to the clip") or
+// follows a condition does not make the sentence a definition.
+export function isDefinitionShape(statement) {
+    if (hasNormativeAssertion(statement))
+        return false;
+    const match = DEFINITION_VERB.exec(statement);
+    if (match === null)
+        return false;
+    const subject = statement.slice(0, match.index);
+    if (subject.trim().length === 0 || CONDITION_OPENER.test(subject))
+        return false;
+    return !/\b(?:that|which|who)\s*$/i.test(subject);
+}
+// implements REQ-kibi-proposition-complete-ingestion
+// Inventories persisted before definitions required the main-predicate shape
+// recorded any clause containing a definition verb as a definition. Accept that
+// stored role so existing knowledge keeps validating; new writes use the
+// advisor's current role.
+export function legacyPropositionRoles(statement) {
+    return DEFINITION_VERB.test(statement) ? ["definition"] : [];
+}
+// implements REQ-kibi-conditional-requirement-authoring
+export function propositionRole(statement, normative) {
+    // Explicit context labels may quote obligations. Incidental explanatory
+    // words within an asserted obligation must not exempt it from grounding.
+    const assertedNormative = normative && hasNormativeAssertion(statement);
+    // A bare desired impression is subjective, even when phrased with should.
+    // Keep concrete actions, quantitative conditions and any independent
+    // obligation assertive instead of exempting them through subjective words.
+    const impression = /\bshould\s+(?:feel\s+(?:welcoming|comfortable|energetic)(?:\s+and\s+(?:welcoming|comfortable|energetic))*|(?:look|seem)\s+complete)\b/i.exec(statement);
+    const impressionTail = impression
+        ? statement.slice(impression.index + impression[0].length).trim()
+        : "";
+    const subjectiveAspiration = impression !== null &&
+        (impressionTail.length === 0 ||
+            /^(?:to|for)\s+[^,;.!?]+$/i.test(impressionTail)) &&
+        !/\b(?:and|or)\b/i.test(impressionTail) &&
+        !/\d|\b(?:at least|at most|exactly|within|no more than)\b/i.test(statement) &&
+        !hasNormativeAssertion(statement.replace(impression[0], ""));
+    if (/^\s*(?:for example\b|e\.g\.|(?:example|illustrative(?: example)?)\s*:)/i.test(statement) ||
+        (!assertedNormative &&
+            /\b(?:for example|e\.g\.|such as|illustrative)\b/i.test(statement)))
+        return "example";
+    if (/^\s*rationale\s*:/i.test(statement) ||
+        (!assertedNormative &&
+            /\b(?:because|so that|in order to| rationale|therefore)\b/i.test(statement)))
+        return "rationale";
+    if (subjectiveAspiration ||
+        (!assertedNormative &&
+            /\b(?:feel|comfortable|looks complete|seems complete|subjective|prefer)\b/i.test(statement)))
+        return "subjective";
+    if (isDefinitionShape(statement))
+        return "definition";
+    if (CONDITION_OPENER.test(statement))
+        return "condition";
+    if (/\b(?:unless|except|exempt|apart from)\b/i.test(statement))
+        return "exception";
+    if (normative)
+        return "normative";
+    return "descriptive";
+}
+// implements REQ-kibi-proposition-complete-ingestion
+// The role the semantic advisor assigns to one claim of a requirement's
+// semantic text. Writers derive persisted inventory roles from it so the
+// write-time proposition-complete check, which compares against the same
+// advisor, never rejects a plan Kibi itself generated.
+export function advisorPropositionRole(semanticText, claimKey, suppliedClauses) {
+    const clause = extractSemanticClauses(semanticText, suppliedClauses).find((entry) => entry.claim_key === claimKey);
+    return clause ? propositionRole(clause.text, clause.normative) : null;
+}

package/dist/public/operations/catalog.d.ts

@@ -693,8 +693,7 @@ export declare const OPERATION_CATALOG: readonly [{
         readonly properties: {
             readonly includeGenericMarkdown: {
                 readonly type: "boolean";
-                readonly default: true;
-                readonly description: "Whether to include generic markdown file content as candidate facts. Default: true.";
+                readonly description: "Whether to include generic markdown file content as candidate facts. Default: true, or false when bootstrapContext declares intentClaims (the declared sources already carry the intent); set it explicitly to override.";
             };
             readonly minConfidence: {
                 readonly type: "number";
@@ -708,7 +707,7 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly default: 50;
                 readonly minimum: 1;
                 readonly maximum: 200;
-                readonly description: "Maximum number of discovered candidates to return. Declared intentClaims are never capped and do not count against it. Clamped to [1, 200]. Default: 50.";
+                readonly description: "Budget for candidates Kibi discovers itself (symbols, tests, repository documents). Declared intentClaims sit outside it: they are never capped and never use its slots. Clamped to [1, 200]. Default: 50.";
             };
             readonly entityTypes: {
                 readonly type: "array";
@@ -799,11 +798,22 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly intentClaims: {
                         readonly type: "array";
                         readonly maxItems: 200;
-                        readonly description: "Statements of product intent the agent harvested from knowledgeSources, each citing its source. Normative claims the strict modeler can ground become cited req candidates; the rest become explicit authoring follow-ups. Bound into the plan hash.";
+                        readonly description: "Statements the agent harvested from knowledgeSources, each citing its source. Intent claims (the default kind) that the strict modeler can ground become cited req candidates; the rest become explicit authoring follow-ups. Observation and open_question claims never become requirements: they become cited fact candidates with fact_kind observation, open questions tagged review:open-question. Every intent and observation claim needs an excerpt: the created entity's body keeps the statement, then a '## Source' section with the blockquoted excerpt, the source title and the reference. Bound into the plan hash.";
                         readonly items: {
                             readonly type: "object";
                             readonly required: readonly ["statement", "sourceId", "reference"];
                             readonly additionalProperties: false;
+                            readonly if: {
+                                readonly properties: {
+                                    readonly kind: {
+                                        readonly const: "open_question";
+                                    };
+                                };
+                                readonly required: readonly ["kind"];
+                            };
+                            readonly else: {
+                                readonly required: readonly ["excerpt"];
+                            };
                             readonly properties: {
                                 readonly statement: {
                                     readonly type: "string";
@@ -821,7 +831,51 @@ export declare const OPERATION_CATALOG: readonly [{
                                 };
                                 readonly excerpt: {
                                     readonly type: "string";
-                                    readonly description: "Optional short quote supporting the claim.";
+                                    readonly minLength: 1;
+                                    readonly description: "Verbatim passage from the source the claim came from. Required for intent and observation claims (optional for open_question): Kibi persists it with the knowledge source title and reference in the created entity's '## Source' section, because the ticket or page may be gone by the next migration.";
+                                };
+                                readonly kind: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["intent", "observation", "open_question"];
+                                    readonly default: "intent";
+                                    readonly description: "intent: intended behavior (may become a req). observation: how things are today, without stating intent. open_question: something the sources leave undecided. Default: intent.";
+                                };
+                            };
+                        };
+                    };
+                    readonly conflicts: {
+                        readonly type: "array";
+                        readonly maxItems: 50;
+                        readonly description: "Contradictions the agent found between declared intentClaims and leaves for the human to resolve. Each becomes a cited fact candidate with fact_kind observation tagged review:conflict. Every claimReference must match a declared claim's sourceId and reference. Bound into the plan hash.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["claimReferences", "note"];
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly claimReferences: {
+                                    readonly type: "array";
+                                    readonly minItems: 2;
+                                    readonly maxItems: 10;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly required: readonly ["sourceId", "reference"];
+                                        readonly additionalProperties: false;
+                                        readonly properties: {
+                                            readonly sourceId: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly reference: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly note: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "What disagrees, in one sentence, without resolving it.";
                                 };
                             };
                         };
@@ -866,7 +920,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_upsert";
     readonly cliName: "upsert";
-    readonly description: "Create or update one entity and optional relationships. Use for KB mutations after validating intent; prefer a dryRun:true call first because it validates without writing and returns semantic advisor receipts for prose-heavy requirements. Use kb_model (mode requirement) before hand-writing strict property facts from prose, and kb_model (mode predicates) before hand-writing ontology predicate facts. Use the `relationships` array for batch creation of multiple links in a single call (e.g., linking a requirement to multiple tests or facts). Prefer modeling requirements as reusable fact links (`constrains`, `requires_property`, or `requires_predicate`) so consistency and contradiction checks remain queryable. Relationship endpoints must already exist in KB. For requirements, the write will be rejected if it contradicts existing current requirements that constrain the same subject with incompatible properties. To replace a conflicting requirement, include a `supersedes` relationship from the new requirement to the old one in the same request, then upsert the old requirement with status closed (kb_check blocks a superseded requirement that is not closed). Successful writes may return non-blocking semantic advisor warnings; inspect and repair those warnings before treating prose as contradiction-checkable. Do not use for read-only inspection. Side effects: writes KB, may refresh symbol coordinates; dryRun:true writes nothing.";
+    readonly description: "Create or update one entity and optional relationships. Use for KB mutations after validating intent; prefer a dryRun:true call first because it validates without writing and returns semantic advisor receipts for prose-heavy requirements. Use kb_model (mode requirement) before hand-writing strict property facts from prose, and kb_model (mode predicates) before hand-writing ontology predicate facts. Use the `relationships` array for batch creation of multiple links in a single call (e.g., linking a requirement to multiple tests or facts). Prefer modeling requirements as reusable fact links (`constrains`, `requires_property`, or `requires_predicate`) so consistency and contradiction checks remain queryable. Relationship endpoints must already exist in KB. For requirements, the write will be rejected if it contradicts existing current requirements that constrain the same subject with incompatible properties. To replace a conflicting requirement, include a `supersedes` relationship from the new requirement to the old one in the same request, then upsert the old requirement with status closed (kb_check blocks a superseded requirement that is not closed). Successful writes may return non-blocking semantic advisor warnings; inspect and repair those warnings before treating prose as contradiction-checkable. Pass a sectioned `document.body` when creating a requirement (the statement, then `## Context` stating why it exists, who asked and the source, then `## Source` with the verbatim excerpt) and a prose body for scenarios, tests, ADRs and observation facts; a result warning reports an entity whose body lacks context, and kb_check blocks it under entity-context-missing. Never invent a reason the requester did not give: write 'Reason not stated'. Do not use for read-only inspection. Side effects: writes KB, may refresh symbol coordinates; dryRun:true writes nothing.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["type", "id", "properties"];
@@ -1407,7 +1461,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     };
                     readonly claim_text: {
                         readonly type: "string";
-                        readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit.";
+                        readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit. Requires claim_key, except on an observation or meta fact, which may quote the clause it is about without claim_key.";
                     };
                     readonly predicate_name: {
                         readonly type: "string";
@@ -1574,7 +1628,7 @@ export declare const OPERATION_CATALOG: readonly [{
             readonly document: {
                 readonly type: "object";
                 readonly additionalProperties: false;
-                readonly description: "Optional source-first document write. Paths are workspace-relative; omit body when updating to preserve the existing body bytes.";
+                readonly description: "Optional source-first document write. Paths are workspace-relative; omit body when updating to preserve the existing body bytes. For a new requirement pass a sectioned body: statement, '## Context' (why, who asked, constraints), '## Source' (blockquoted excerpt and reference); context never changes the checked meaning, which stays in semantic_text.";
                 readonly properties: {
                     readonly path: {
                         readonly type: "string";
@@ -1663,7 +1717,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, 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, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance. 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 description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, 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, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged. 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";
@@ -1791,6 +1845,21 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly enum: readonly ["create", "update"];
                 readonly description: "Create a new requirement or update an existing one. Update auto-selection is allowed only with a high-confidence, well-separated candidate.";
             };
+            readonly context: {
+                readonly type: "string";
+                readonly maxLength: 10000;
+                readonly description: "Why the requirement exists, who asked and anything that does not fit its checked meaning. Required when mode is create (validation error naming this field otherwise); rendered as a '## Context' section of the requirement document, never as part of the checked meaning. Never invent a reason: write 'Reason not stated' when the requester gave none. An update keeps the existing document body unless context is supplied.";
+            };
+            readonly sourceExcerpt: {
+                readonly type: "string";
+                readonly maxLength: 10000;
+                readonly description: "Optional verbatim text the intent came from (a ticket, a message, a document passage). Rendered as a blockquote in the requirement's '## Source' section; requires context.";
+            };
+            readonly sourceReference: {
+                readonly type: "string";
+                readonly maxLength: 2000;
+                readonly description: "Optional locator of the source text (ticket id, URL, path). Rendered in the requirement's '## Source' section; requires context.";
+            };
             readonly requirementId: {
                 readonly type: "string";
                 readonly description: "Optional exact requirement ID. Required for an update when automatic selection is below the confidence and margin gates.";

package/dist/public/operations/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/check-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAElB,MAAM,oBAAoB,CAAC;AAS5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAMvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAqDF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAsKxC"}
+{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAElB,MAAM,oBAAoB,CAAC;AAU5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAMvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAqDF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA2KxC"}

package/dist/public/operations/check-executor.js

@@ -3,6 +3,7 @@ import { collectFullKbQualityDiagnostics } from "../impact-diagnostics.js";
 import { buildStructuredContent, buildSummary, } from "./check-format-shared.js";
 import { analyzeKbCheckImpact, collectQueryPlanSafetyViolations, getEffectiveRules, partitionCheckFindings, qualityDiagnosticsFromImpact, resolveCheckRules, stagedEntityIdStyleDiagnostics, } from "./check-helpers.js";
 import { executeStatus } from "./discovery-executors.js";
+import { collectEntityContextViolations } from "./entity-context.js";
 import { buildActionsFromCheck, buildMigrationPlan, mergeMigrationPlans, } from "./migration-plan.js";
 import { collectOriginReviewViolations } from "./origin-review.js";
 import { collectPredicateSchemaConformanceViolations } from "./predicate-schema-conformance.js";
@@ -122,6 +123,7 @@ export async function executeCheck(args, context, options = {}) {
             ? collectSourcePathDanglingViolations(workspaceRoot)
             : [];
         const originReviewFindings = await collectOriginReviewViolations(prolog, rulesAllowlist, workspaceRoot);
+        const entityContextFindings = collectEntityContextViolations(rulesAllowlist, workspaceRoot);
         const partitioned = partitionCheckFindings([
             ...aggregatedFindings,
             ...queryPlanViolations,
@@ -129,6 +131,7 @@ export async function executeCheck(args, context, options = {}) {
             ...sourcePathFindings,
             ...predicateConformanceFindings,
             ...originReviewFindings,
+            ...entityContextFindings,
         ]);
         const violations = partitioned.violations;
         const diagnostics = violations.map((v) => ({

package/dist/public/operations/entity-context.d.ts

@@ -0,0 +1,51 @@
+import type { Violation } from "../../utils/rule-registry.js";
+/** A current entity must carry body context (blocking). */
+export declare const ENTITY_CONTEXT_MISSING_RULE = "entity-context-missing";
+/** How many legacy entities carry the review:context-missing tag (advisory). */
+export declare const ENTITY_CONTEXT_ACKNOWLEDGED_RULE = "entity-context-acknowledged";
+export declare const ENTITY_CONTEXT_RULES: readonly ["entity-context-missing", "entity-context-acknowledged"];
+/** One authored entity document, front matter and body kept apart. */
+export type AuthoredEntity = Readonly<{
+    id: string;
+    type: string;
+    path: string;
+    data: Readonly<Record<string, unknown>>;
+    body: string;
+}>;
+/**
+ * Split an authored Markdown document into its front matter record and its
+ * body. Returns null when the front matter is absent or does not parse.
+ */
+export declare function readAuthoredEntity(content: string, relativePath: string): AuthoredEntity | null;
+/**
+ * The checked meaning a requirement's context is compared against. A
+ * `semantic_text` that schema 8 pinned from the old derivation (statement plus
+ * context sections) is the body's derivation, not a statement of its own, so
+ * it is replaced by the statement-only derivation; an authored value stands.
+ */
+export declare function contextStatementOf(entity: AuthoredEntity): string | undefined;
+/** The entity fields the context rules read, with the derived meaning. */
+export declare function contextEntityOf(entity: AuthoredEntity): {
+    title: unknown;
+    semantic_text: unknown;
+    fact_kind: unknown;
+    tags: unknown;
+};
+/** Whether an authored entity is current: not retired, not superseded. */
+export declare function isCurrentAuthoredEntity(entity: AuthoredEntity, superseded: ReadonlySet<string>): boolean;
+/** Every authored entity of a type the context rules apply to. */
+export declare function listContextAuthoredEntities(workspaceRoot: string): AuthoredEntity[];
+/**
+ * Ids some other entity supersedes, read from authored `links` and the
+ * relationship shards so the check and the migration agree before a sync.
+ */
+export declare function authoredSupersededIds(workspaceRoot: string, entities: readonly AuthoredEntity[]): Set<string>;
+/**
+ * Evaluate the context rules over authored entities. Entities tagged
+ * review:context-missing are acknowledged legacy: they never violate, and one
+ * advisory finding counts them.
+ */
+export declare function evaluateEntityContext(entities: readonly AuthoredEntity[], superseded: ReadonlySet<string>, rules?: ReadonlySet<string>, acknowledgedIds?: ReadonlySet<string>): Violation[];
+/** Read the authored entities once and evaluate the selected rules. */
+export declare function collectEntityContextViolations(rules: ReadonlySet<string>, workspaceRoot: string): Violation[];
+//# sourceMappingURL=entity-context.d.ts.map

package/dist/public/operations/entity-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-context.d.ts","sourceRoot":"","sources":["../../../src/public/operations/entity-context.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,2DAA2D;AAE3D,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AACpE,gFAAgF;AAEhF,eAAO,MAAM,gCAAgC,gCAAgC,CAAC;AAG9E,eAAO,MAAM,oBAAoB,oEAGvB,CAAC;AAUX,sEAAsE;AAEtE,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACxC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAEH;;;GAGG;AAEH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB,cAAc,GAAG,IAAI,CA6BvB;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAW7E;AAED,0EAA0E;AAE1E,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG;IACvD,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACf,CAOA;AAED,0EAA0E;AAE1E,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,OAAO,CAMT;AAUD,kEAAkE;AAElE,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,GACpB,cAAc,EAAE,CAclB;AAED;;;GAGG;AAEH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,SAAS,cAAc,EAAE,GAClC,GAAG,CAAC,MAAM,CAAC,CAwBb;AAED;;;;GAIG;AAEH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,EAC/B,KAAK,GAAE,WAAW,CAAC,MAAM,CAAiC,EAC1D,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,SAAS,EAAE,CAqDb;AAED,uEAAuE;AAEvE,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,aAAa,EAAE,MAAM,GACpB,SAAS,EAAE,CASb"}