kibi-cli 2.1.0 → 2.2.0

package/dist/operations/modeling/predicate-vocabulary.js

@@ -0,0 +1,169 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Structured fields arrive as objects from Markdown or as JSON strings from Prolog. */
+function structuredField(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Read a schema's vocabulary. Malformed entries are ignored here; use
+ * {@link predicateVocabularyErrors} to report them.
+ */
+// implements REQ-kibi-predicate-argument-constants
+export function predicateVocabularyFromEntity(entity) {
+    const rawConstants = structuredField(entity.argument_constants);
+    const rawAliases = structuredField(entity.argument_aliases);
+    const constants = {};
+    if (isRecord(rawConstants)) {
+        for (const [name, values] of Object.entries(rawConstants)) {
+            if (!Array.isArray(values))
+                continue;
+            const strings = values.filter((value) => typeof value === "string" && value.length > 0);
+            if (strings.length > 0)
+                constants[name] = [...new Set(strings)];
+        }
+    }
+    const aliases = {};
+    if (isRecord(rawAliases)) {
+        for (const [name, mapping] of Object.entries(rawAliases)) {
+            if (!isRecord(mapping))
+                continue;
+            const entries = Object.entries(mapping).filter((entry) => typeof entry[1] === "string" && entry[1].length > 0);
+            if (entries.length > 0)
+                aliases[name] = Object.fromEntries(entries);
+        }
+    }
+    return { constants, aliases };
+}
+// implements REQ-kibi-predicate-argument-constants
+export function hasPredicateVocabulary(vocabulary) {
+    return (Object.keys(vocabulary.constants).length > 0 ||
+        Object.keys(vocabulary.aliases).length > 0);
+}
+/**
+ * Cross-field errors in a predicate schema's vocabulary: every key must be an
+ * argument name, aliases need declared constants for their argument, alias
+ * targets must be declared, and an alias may not shadow a constant.
+ */
+// implements REQ-kibi-predicate-argument-constants
+export function predicateVocabularyErrors(entity) {
+    const errors = [];
+    const rawConstants = structuredField(entity.argument_constants);
+    const rawAliases = structuredField(entity.argument_aliases);
+    if (rawConstants === undefined && rawAliases === undefined)
+        return errors;
+    if (entity.fact_kind !== "predicate_schema") {
+        errors.push("argument_constants and argument_aliases are only valid on fact_kind predicate_schema");
+        return errors;
+    }
+    const argumentNames = Array.isArray(entity.argument_names)
+        ? entity.argument_names.filter((name) => typeof name === "string")
+        : [];
+    if (rawConstants !== undefined && !isRecord(rawConstants)) {
+        errors.push("argument_constants must map argument names to constant lists");
+    }
+    if (rawAliases !== undefined && !isRecord(rawAliases)) {
+        errors.push("argument_aliases must map argument names to alias-to-constant objects");
+    }
+    const vocabulary = predicateVocabularyFromEntity(entity);
+    if (isRecord(rawConstants)) {
+        for (const [name, values] of Object.entries(rawConstants)) {
+            if (!argumentNames.includes(name)) {
+                errors.push(`argument_constants.${name} is not one of argument_names (${argumentNames.join(", ")})`);
+            }
+            if (!Array.isArray(values) ||
+                values.length === 0 ||
+                values.some((value) => typeof value !== "string" || value === "")) {
+                errors.push(`argument_constants.${name} must be a non-empty list of non-empty strings`);
+            }
+        }
+    }
+    if (isRecord(rawAliases)) {
+        for (const [name, mapping] of Object.entries(rawAliases)) {
+            if (!argumentNames.includes(name)) {
+                errors.push(`argument_aliases.${name} is not one of argument_names (${argumentNames.join(", ")})`);
+                continue;
+            }
+            const declared = vocabulary.constants[name];
+            if (declared === undefined) {
+                errors.push(`argument_aliases.${name} requires argument_constants.${name} to declare the canonical constants`);
+                continue;
+            }
+            if (!isRecord(mapping)) {
+                errors.push(`argument_aliases.${name} must map alias spellings to constants`);
+                continue;
+            }
+            for (const [alias, target] of Object.entries(mapping)) {
+                if (typeof target !== "string" || !declared.includes(target)) {
+                    errors.push(`argument_aliases.${name}.${alias} must name a declared constant of ${name}`);
+                }
+                if (declared.includes(alias)) {
+                    errors.push(`argument_aliases.${name}.${alias} shadows a declared constant; remove the alias`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Compare predicate arguments with a schema vocabulary. Open arguments always
+ * conform; an alias is reported as a rewrite, anything else not declared is
+ * reported as undeclared.
+ */
+// implements REQ-kibi-predicate-argument-constants
+export function predicateArgumentConformance(argumentNames, args, vocabulary) {
+    const rewrites = [];
+    const undeclared = [];
+    args.forEach((value, index) => {
+        const argumentName = argumentNames[index];
+        if (argumentName === undefined)
+            return;
+        const allowed = vocabulary.constants[argumentName];
+        if (allowed === undefined || allowed.includes(value))
+            return;
+        const canonical = vocabulary.aliases[argumentName]?.[value];
+        if (canonical !== undefined && allowed.includes(canonical)) {
+            rewrites.push({ index, argumentName, from: value, to: canonical });
+            return;
+        }
+        undeclared.push({ index, argumentName, value, allowed });
+    });
+    return { rewrites, undeclared };
+}
+/** Arguments with every alias replaced by its declared constant. */
+// implements REQ-kibi-predicate-argument-constants
+export function applyArgumentRewrites(args, rewrites) {
+    const next = [...args];
+    for (const rewrite of rewrites)
+        next[rewrite.index] = rewrite.to;
+    return next;
+}
+/** Canonical key convention shared with predicate apply plans. */
+// implements REQ-kibi-predicate-argument-constants
+export function predicateCanonicalKey(predicateName, args) {
+    return `${predicateName}(${args.join(",")})`;
+}

package/dist/operations/modeling/requirement-types.d.ts

@@ -1,5 +1,6 @@
 import type { LogicRuleIR } from "../../logic/ir.js";
 import type { SemanticClaim, StrictWriteSet } from "../../public/check-types.js";
+import type { VocabularyAlignmentOutcome } from "./vocabulary-alignment.js";
 export type ModelRequirementArgs = Readonly<Record<string, unknown>> & {
     readonly text: string;
     readonly source?: string;
@@ -46,6 +47,10 @@ export interface ModelRequirementResult {
             nextAction: string;
         }>;
         migrationWarning: string | null;
+        /** Subject reuse decision and possible-duplicate review candidates. */
+        vocabularyAlignment?: VocabularyAlignmentOutcome & {
+            readonly reviewPlan: Array<Record<string, unknown>>;
+        };
         logic?: {
             readonly semanticKey: string;
             readonly claimKey: string;

package/dist/operations/modeling/requirement-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requirement-types.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/requirement-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACf,MAAM,6BAA6B,CAAC;AAGrC,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,iFAAiF;IACjF,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAGF,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,aAAa,CAAC;IACrB,cAAc,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;IACtD,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAGD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,KAAK,EAAE,aAAa,CAAC;QACrB,QAAQ,EAAE,cAAc,CAAC;QACzB,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAC1C,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;QACtD,kBAAkB,EAAE,MAAM,EAAE,CAAC;QAC7B,QAAQ,EAAE,KAAK,CAAC;YACd,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;YAChB,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC,CAAC;QACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,KAAK,CAAC,EAAE;YACN,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;YAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;YAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;YAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;YAChC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;SAClC,CAAC;KACH,CAAC;IACF,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1C,QAAQ,EAAE,cAAc,CAAC;IACzB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC"}
+{"version":3,"file":"requirement-types.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/requirement-types.ts"],"names":[],"mappings":"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"}

package/dist/operations/modeling/vocabulary-alignment.d.ts

@@ -0,0 +1,60 @@
+import { type SubjectVocabularyEntry } from "kibi-plugin-builtin";
+import { type SubjectCandidate } from "kibi-plugin-sdk";
+import { publicCapabilityStamp } from "../../plugins/compose-semantic-classifier.js";
+import { type VocabularyAlignmentDiagnostic } from "../../plugins/compose-vocabulary-alignment.js";
+import type { OperationContext, PrologPort } from "../../public/operations/runtime-types.js";
+export type SubjectResolution = Readonly<{
+    /** reuse_existing: the plan links the existing subject fact. */
+    decision: "reuse_existing" | "declare_new";
+    subjectKey: string;
+    /** Existing subject fact linked via constrains when reusing. */
+    existingFactId: string | null;
+    confidence: number;
+    candidates: readonly SubjectCandidate[];
+}>;
+export type RedundancyCandidate = Readonly<{
+    factId: string;
+    subjectKey: string;
+    requirementIds: readonly string[];
+    claimText: string;
+    signature: string;
+    confidence: number;
+}>;
+export type VocabularyAlignmentOutcome = Readonly<{
+    subject: SubjectResolution;
+    redundancyCandidates: readonly RedundancyCandidate[];
+    stamps: readonly ReturnType<typeof publicCapabilityStamp>[];
+    fallbackUsed: boolean;
+    diagnostics: readonly VocabularyAlignmentDiagnostic[];
+}>;
+type SubjectClaim = Readonly<{
+    factId: string;
+    subjectKey: string;
+    signature: string;
+    claimText?: string;
+    title?: string;
+    requirements?: readonly string[];
+}>;
+type VocabularyEntryWithFact = SubjectVocabularyEntry & {
+    factId: string;
+    /** Rejected by subject-key-identity; never proposed for reuse. */
+    reqDerived?: boolean;
+};
+export declare function readSubjectVocabulary(prolog: PrologPort): Promise<VocabularyEntryWithFact[]>;
+export declare function readSubjectClaims(prolog: PrologPort, subjectKeys: readonly string[]): Promise<SubjectClaim[]>;
+/**
+ * Rank existing subjects for one modeled clause and look for possible
+ * paraphrase duplicates among claims already on the chosen subject.
+ *
+ * The builtin ranker always runs; a configured kibi.vocabulary-alignment.v1
+ * provider may refine the choice (replace / augment / shadow). The outcome is
+ * modeling advice: exact duplicate detection stays with the deterministic
+ * Prolog `domain-redundancy` check.
+ */
+export declare function alignRequirementVocabulary(context: OperationContext, clause: Readonly<{
+    claimKey: string;
+    statement: string;
+    proposedSubjectKey: string;
+}>): Promise<VocabularyAlignmentOutcome | null>;
+export {};
+//# sourceMappingURL=vocabulary-alignment.d.ts.map

package/dist/operations/modeling/vocabulary-alignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocabulary-alignment.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/vocabulary-alignment.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EACL,KAAK,6BAA6B,EAGnC,MAAM,+CAA+C,CAAC;AAOvD,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACX,MAAM,0CAA0C,CAAC;AAMlD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,gEAAgE;IAChE,QAAQ,EAAE,gBAAgB,GAAG,aAAa,CAAC;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACzC,CAAC,CAAC;AAGH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AAGH,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,oBAAoB,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,MAAM,EAAE,SAAS,UAAU,CAAC,OAAO,qBAAqB,CAAC,EAAE,CAAC;IAC5D,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,SAAS,6BAA6B,EAAE,CAAC;CACvD,CAAC,CAAC;AAEH,KAAK,YAAY,GAAG,QAAQ,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC,CAAC;AAEH,KAAK,uBAAuB,GAAG,sBAAsB,GAAG;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AA6BF,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAMpC;AAGD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,OAAO,CAAC,YAAY,EAAE,CAAC,CAQzB;AAwCD;;;;;;;;GAQG;AAEH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC,GACD,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAgG5C"}

package/dist/operations/modeling/vocabulary-alignment.js

@@ -0,0 +1,178 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import path from "node:path";
+import { rankSubjectCandidates, } from "kibi-plugin-builtin";
+import { NEW_SUBJECT_CHOICE, } from "kibi-plugin-sdk";
+import { publicCapabilityStamp } from "../../plugins/compose-semantic-classifier.js";
+import { composeClaimComparison, composeSubjectRanking, } from "../../plugins/compose-vocabulary-alignment.js";
+import { createCapabilityRegistry, } from "../../plugins/registry.js";
+import { resolveKbPlPath } from "../../prolog.js";
+import { escapeAtom, toPrologAtom } from "../../prolog/codec.js";
+/** Operation name used for the external-provider allowlist. */
+const OPERATION_NAME = "kb_model_requirement";
+function semanticQualityModulePath() {
+    return path.join(path.dirname(resolveKbPlPath()), "semantic_quality.pl");
+}
+function parseJsonBinding(raw) {
+    if (raw === undefined || raw === "")
+        return [];
+    let parsed = JSON.parse(raw);
+    if (typeof parsed === "string")
+        parsed = JSON.parse(parsed);
+    return parsed;
+}
+async function queryJson(prolog, goal) {
+    const modulePath = escapeAtom(semanticQualityModulePath());
+    // call/1 defers module resolution until use_module has loaded the module;
+    // a literal qualified goal is checked when the query is read.
+    const result = await prolog.query(`(use_module('${modulePath}'), call(${goal}))`);
+    if (!result.success) {
+        throw new Error(`Vocabulary query failed: ${result.error ?? "unknown error"}`);
+    }
+    return parseJsonBinding(result.bindings.Json);
+}
+// implements REQ-kibi-subject-vocabulary
+export async function readSubjectVocabulary(prolog) {
+    const parsed = await queryJson(prolog, "semantic_quality:subject_vocabulary_json(Json)");
+    return Array.isArray(parsed) ? parsed : [];
+}
+// implements REQ-kibi-subject-vocabulary
+export async function readSubjectClaims(prolog, subjectKeys) {
+    if (subjectKeys.length === 0)
+        return [];
+    const list = subjectKeys.map((key) => toPrologAtom(key)).join(",");
+    const parsed = await queryJson(prolog, `semantic_quality:subject_claims_json([${list}], Json)`);
+    return Array.isArray(parsed) ? parsed : [];
+}
+/**
+ * Keep an existing subject whose key equals the proposed key among the
+ * candidates even when it ranks outside the top k, so the plan reuses it
+ * instead of declaring a second subject fact with the same key.
+ */
+function withExactSubject(candidates, vocabulary, proposedSubjectKey) {
+    if (candidates.some((c) => c.subjectKey === proposedSubjectKey)) {
+        return [...candidates];
+    }
+    const exact = vocabulary.find((entry) => entry.subjectKey === proposedSubjectKey);
+    if (exact === undefined)
+        return [...candidates];
+    return [
+        ...candidates,
+        {
+            subjectKey: exact.subjectKey,
+            score: 0,
+            ...(exact.title !== undefined ? { title: exact.title } : {}),
+        },
+    ];
+}
+async function resolveRegistry(context) {
+    if (context.ensurePlugins)
+        return context.ensurePlugins();
+    // Hosts without a plugin runtime get the builtin provider only.
+    return createCapabilityRegistry({
+        workspaceRoot: context.workspaceRoot,
+        projectConfig: {},
+    });
+}
+/**
+ * Rank existing subjects for one modeled clause and look for possible
+ * paraphrase duplicates among claims already on the chosen subject.
+ *
+ * The builtin ranker always runs; a configured kibi.vocabulary-alignment.v1
+ * provider may refine the choice (replace / augment / shadow). The outcome is
+ * modeling advice: exact duplicate detection stays with the deterministic
+ * Prolog `domain-redundancy` check.
+ */
+// implements REQ-kibi-subject-vocabulary, REQ-kibi-vocabulary-alignment-capability
+export async function alignRequirementVocabulary(context, clause) {
+    const prolog = context.prolog;
+    if (!prolog)
+        return null;
+    const vocabulary = (await readSubjectVocabulary(prolog)).filter((entry) => entry.reqDerived !== true);
+    const candidates = withExactSubject(rankSubjectCandidates(clause.statement, vocabulary), vocabulary, clause.proposedSubjectKey);
+    const registry = await resolveRegistry(context);
+    const resolution = await registry.resolveVocabularyAlignment();
+    const ranking = await composeSubjectRanking(resolution, {
+        clauses: [
+            {
+                claimKey: clause.claimKey,
+                text: clause.statement,
+                proposedSubjectKey: clause.proposedSubjectKey,
+                candidates,
+            },
+        ],
+    }, { operationName: OPERATION_NAME });
+    const decision = ranking.results[0];
+    const chosen = decision !== undefined && decision.choice !== NEW_SUBJECT_CHOICE
+        ? vocabulary.find((entry) => entry.subjectKey === decision.choice)
+        : undefined;
+    const subject = chosen
+        ? {
+            decision: "reuse_existing",
+            subjectKey: chosen.subjectKey,
+            existingFactId: chosen.factId,
+            confidence: decision?.confidence ?? 0,
+            candidates,
+        }
+        : {
+            decision: "declare_new",
+            subjectKey: clause.proposedSubjectKey,
+            existingFactId: null,
+            confidence: decision?.confidence ?? 1,
+            candidates,
+        };
+    let redundancyCandidates = [];
+    let comparison = null;
+    if (subject.decision === "reuse_existing") {
+        const claims = await readSubjectClaims(prolog, [subject.subjectKey]);
+        const pairs = claims.map((claim) => ({
+            pairKey: claim.factId,
+            sharedKey: subject.subjectKey,
+            left: { claimText: clause.statement },
+            right: {
+                claimText: claim.claimText || claim.title || claim.factId,
+                signature: claim.signature,
+                factId: claim.factId,
+            },
+        }));
+        comparison = await composeClaimComparison(resolution, { pairs }, { operationName: OPERATION_NAME });
+        const claimsById = new Map(claims.map((claim) => [claim.factId, claim]));
+        redundancyCandidates = comparison.results.flatMap((judgment) => {
+            const claim = claimsById.get(judgment.pairKey);
+            if (!judgment.sameObligation || claim === undefined)
+                return [];
+            return [
+                {
+                    factId: claim.factId,
+                    subjectKey: claim.subjectKey,
+                    requirementIds: claim.requirements ?? [],
+                    claimText: claim.claimText || claim.title || "",
+                    signature: claim.signature,
+                    confidence: judgment.confidence,
+                },
+            ];
+        });
+    }
+    return {
+        subject,
+        redundancyCandidates,
+        stamps: [...ranking.stamps, ...(comparison?.stamps ?? [])].map(publicCapabilityStamp),
+        fallbackUsed: ranking.fallbackUsed || comparison?.fallbackUsed === true,
+        diagnostics: [...ranking.diagnostics, ...(comparison?.diagnostics ?? [])],
+    };
+}

package/dist/operations/mutation/contradictions.d.ts

@@ -6,6 +6,9 @@ type TransactionInput = {
     readonly skipContradictionCheck: boolean;
 };
 export declare function buildUpsertCommitGoal(input: TransactionInput): string;
+/** One transaction and one journal flush for a receipt campaign. */
+export declare function buildUpsertBatchCommitGoal(inputs: readonly TransactionInput[]): string;
+export declare function parseUpsertChangeKinds(bindings: Readonly<Record<string, string>>, count: number): Array<"created" | "updated">;
 export declare function formatUpsertError(entityId: string, raw?: string, record?: PrologErrorRecord): string;
 export {};
 //# sourceMappingURL=contradictions.d.ts.map

package/dist/operations/mutation/contradictions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contradictions.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/contradictions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AASrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;CAC1C,CAAC;AAGF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAOrE;AAGD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,iBAAiB,GACzB,MAAM,CAOR"}
+{"version":3,"file":"contradictions.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/contradictions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AASrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;CAC1C,CAAC;AAGF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAOrE;AAWD,oEAAoE;AAEpE,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAClC,MAAM,CAKR;AAGD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC1C,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,CAe9B;AAGD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,iBAAiB,GACzB,MAAM,CAOR"}

package/dist/operations/mutation/contradictions.js

@@ -7,6 +7,35 @@ export function buildUpsertCommitGoal(input) {
     const relationships = input.relationships.map((relationship) => `rel(${String(relationship.type)}, '${escapeAtom(String(relationship.from))}', '${escapeAtom(String(relationship.to))}', ${buildRelationshipMetadata(relationship)})`);
     return `kb_commit_upsert(${type}, ${buildPropertyList(input.entity)}, [${relationships.join(", ")}], ${input.skipContradictionCheck ? "true" : "false"}, ChangeKind)`;
 }
+function upsertBatchEntry(input) {
+    const type = String(input.entity.type);
+    const relationships = input.relationships.map((relationship) => `rel(${String(relationship.type)}, '${escapeAtom(String(relationship.from))}', '${escapeAtom(String(relationship.to))}', ${buildRelationshipMetadata(relationship)})`);
+    return `upsert(${type}, ${buildPropertyList(input.entity)}, [${relationships.join(", ")}], ${input.skipContradictionCheck ? "true" : "false"})`;
+}
+/** One transaction and one journal flush for a receipt campaign. */
+// implements REQ-core-atomic-upsert-persistence
+export function buildUpsertBatchCommitGoal(inputs) {
+    const first = inputs[0];
+    if (!first)
+        throw new Error("Upsert batch requires at least one entity");
+    if (inputs.length === 1)
+        return buildUpsertCommitGoal(first);
+    return `kb_commit_upsert_batch([${inputs.map(upsertBatchEntry).join(", ")}], ChangeKinds)`;
+}
+// implements REQ-core-atomic-upsert-persistence
+export function parseUpsertChangeKinds(bindings, count) {
+    const listed = bindings.ChangeKinds;
+    if (typeof listed === "string") {
+        const kinds = [...listed.matchAll(/\b(created|updated)\b/g)].map((match) => match[1]);
+        if (kinds.length === count)
+            return kinds;
+    }
+    const one = bindings.ChangeKind;
+    if ((one === "created" || one === "updated") && count >= 1) {
+        return Array.from({ length: count }, () => one);
+    }
+    throw new Error(`Upsert batch completed without ${count} created/updated result(s)`);
+}
 // implements REQ-kibi-operation-interface-parity
 export function formatUpsertError(entityId, raw, record) {
     const stage = raw?.match(/\(stage=([^)]+)\)/)?.[1];

package/dist/operations/mutation/delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/delete.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,+BAA+B,CAAC;AAgBvC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAc7D,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,gBAAgB,CAAC,IAAI,CAAC,GACzB,OAAO,CAAC,EAAE,IAAI,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAMnD;AAuWD,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,SAAS,oBAAoB,EAAE,EAC1C,OAAO,EAAE,gBAAgB,EACzB,WAAW,GAAE,MAAM,IAAsB,GACxC,OAAO,CAAC,aAAa,CAAC,CA4BxB;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CA6OzC"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/delete.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EACL,KAAK,oBAAoB,EAM1B,MAAM,+BAA+B,CAAC;AAgBvC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAc7D,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,gBAAgB,CAAC,IAAI,CAAC,GACzB,OAAO,CAAC,EAAE,IAAI,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAMnD;AAuWD,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,SAAS,oBAAoB,EAAE,EAC1C,OAAO,EAAE,gBAAgB,EACzB,WAAW,GAAE,MAAM,IAAsB,GACxC,OAAO,CAAC,aAAa,CAAC,CA4BxB;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CA8QzC"}

package/dist/operations/mutation/delete.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { InputError, OperationError } from "../../cli-errors.js";
 import { parseEntityFromList, parseListOfLists, toPrologAtom, } from "../../prolog/codec.js";
-import { listShards, readAllShards, removeRelationshipsFromShards, } from "../../relationships/shards.js";
+import { listShards, readAllShards, readShard, removeRelationshipsFromShards, renderShardWithout, } from "../../relationships/shards.js";
 import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
 import { buildEntityDeleteAuditGoal } from "./audit.js";
 import { RELATIONSHIP_TYPES, dependentRelationshipsGoal, } from "./relationships.js";
@@ -447,6 +447,36 @@ export async function executeDelete(input, context) {
             goals.push(buildEntityDeleteAuditGoal(entity));
         }
         if (authoredIds.length > 0 && context.sourcePlanApplication !== true) {
+            if (context.fs) {
+                // A deleted entity's outgoing relationships live in canonical shards,
+                // not in its own document. Incoming edges already block deletion, so
+                // the plan removes the outgoing rows too; otherwise the compiled
+                // store drops them while the shards keep them.
+                const deleted = new Set(authoredIds);
+                for (const shardPath of listShards(path.join(context.workspaceRoot, ".kb"))) {
+                    const selectors = readShard(shardPath)
+                        .filter((record) => deleted.has(record.from))
+                        .map(({ type, from, to }) => ({ type, from, to }));
+                    if (selectors.length === 0)
+                        continue;
+                    const relativeShard = path
+                        .relative(context.workspaceRoot, shardPath)
+                        .replaceAll("\\", "/");
+                    const original = readFileSync(shardPath, "utf8");
+                    const body = renderShardWithout(original, selectors, shardPath);
+                    const beforeHash = createHash("sha256")
+                        .update(original)
+                        .digest("hex");
+                    sourceHashes[relativeShard] = beforeHash;
+                    sourcePlansByPath.set(relativeShard, {
+                        path: relativeShard,
+                        mode: "write",
+                        beforeHash,
+                        afterHash: createHash("sha256").update(body).digest("hex"),
+                        body,
+                    });
+                }
+            }
             const supersessionRequired = authoredRequirementIds.length > 0;
             const sourcePlans = [...sourcePlansByPath.values()];
             const planBody = {
@@ -468,6 +498,8 @@ export async function executeDelete(input, context) {
                         : "Authored entity deletion returns a hash-bound plan for kb_apply_plan.",
                 ],
                 deletionPlan: { ...planBody, planHash },
+                // Only kb_apply_plan writes; this call returns the plan.
+                skippedEffects: ["kb-write", "workspace-write"],
             };
             return {
                 content: [

package/dist/operations/mutation/predicate-vocabulary-guard.d.ts

@@ -0,0 +1,8 @@
+import type { PrologPort } from "../../public/operations/runtime-types.js";
+/**
+ * Reject a predicate fact whose arguments fall outside the constants its
+ * project-local schema declares. An alias is rejected too, with the declared
+ * constant to use instead, so new facts never need migrating.
+ */
+export declare function assertPredicateArgumentVocabulary(prolog: Pick<PrologPort, "query">, entity: Readonly<Record<string, unknown>>): Promise<void>;
+//# sourceMappingURL=predicate-vocabulary-guard.d.ts.map

package/dist/operations/mutation/predicate-vocabulary-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-vocabulary-guard.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/predicate-vocabulary-guard.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAY3E;;;;GAIG;AAEH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CA+Cf"}

package/dist/operations/mutation/predicate-vocabulary-guard.js

@@ -0,0 +1,64 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { parseEntityFromList, parseListOfLists, toPrologAtom, } from "../../prolog/codec.js";
+import { predicateArgumentConformance, predicateVocabularyFromEntity, } from "../modeling/predicate-vocabulary.js";
+function text(value) {
+    return typeof value === "string" && value.trim() !== ""
+        ? value.trim()
+        : undefined;
+}
+/**
+ * Reject a predicate fact whose arguments fall outside the constants its
+ * project-local schema declares. An alias is rejected too, with the declared
+ * constant to use instead, so new facts never need migrating.
+ */
+// implements REQ-kibi-predicate-argument-constants
+export async function assertPredicateArgumentVocabulary(prolog, entity) {
+    if (entity.type !== "fact" || entity.fact_kind !== "predicate")
+        return;
+    const name = text(entity.predicate_name);
+    const args = Array.isArray(entity.predicate_args)
+        ? entity.predicate_args.filter((value) => typeof value === "string")
+        : [];
+    if (name === undefined || args.length === 0)
+        return;
+    const namespace = text(entity.predicate_namespace) ?? "default";
+    const result = await prolog.query(`findall([Id,'fact',Props], (kb:predicate_schema(Id, Namespace, Name, Arity, _Names, _Types), Name == ${toPrologAtom(name)}, Namespace == ${toPrologAtom(namespace)}, Arity =:= ${args.length}, kb_entity(Id, 'fact', Props)), Results)`);
+    if (!result.success) {
+        throw new Error(`Predicate schema lookup failed: ${result.error ?? "unknown error"}`);
+    }
+    const schemas = result.bindings.Results
+        ? parseListOfLists(result.bindings.Results).map(parseEntityFromList)
+        : [];
+    const problems = [];
+    for (const schema of schemas) {
+        const argumentNames = Array.isArray(schema.argument_names)
+            ? schema.argument_names.map(String)
+            : [];
+        const conformance = predicateArgumentConformance(argumentNames, args, predicateVocabularyFromEntity(schema));
+        for (const rewrite of conformance.rewrites) {
+            problems.push(`argument ${rewrite.argumentName} uses alias ${rewrite.from}; use the declared constant ${rewrite.to} (${String(schema.id)})`);
+        }
+        for (const value of conformance.undeclared) {
+            problems.push(`argument ${value.argumentName} value ${value.value} is not declared by ${String(schema.id)}; allowed: ${value.allowed.join(", ")}`);
+        }
+    }
+    if (problems.length > 0) {
+        throw new Error(`Entity validation failed: ${problems.join("; ")}. Use a declared constant, or extend the schema's argument_constants when the value is genuinely new.`);
+    }
+}

package/dist/operations/mutation/relationships.d.ts

@@ -1,6 +1,6 @@
 import type { PrologPort } from "../../public/operations/runtime-types.js";
 import type { RelationshipInput } from "./types.js";
-export declare const RELATIONSHIP_TYPES: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "relates_to"];
+export declare const RELATIONSHIP_TYPES: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "restates", "relates_to"];
 export type RelationshipType = (typeof RELATIONSHIP_TYPES)[number];
 export declare function wrongKindRelationshipError(type: string, target: string, wrongKind: string): Error;
 export declare function dependentRelationshipsGoal(entityId: string): string;