kibi-cli 2.3.0 → 2.5.0

package/dist/operations/modeling/model-requirement.js

@@ -1,7 +1,9 @@
 import { buildStrictWriteSet, } from "../../public/check-types.js";
 import { readKbManifestStatus } from "../../utils/kb-manifest.js";
 import { isConventionalSubjectKey, normalizeSubjectKey, } from "../../utils/strict-modeling.js";
-import { normalizeSemanticClause, semanticClaimKey, } from "../semantic-advisor/clauses.js";
+import { propositionRole } from "../semantic-advisor/analyze-prose.js";
+import { extractSemanticClauses, modeledClaimRole, normalizeSemanticClause, semanticClaimKey, } from "../semantic-advisor/clauses.js";
+import { detectConditionalRule } from "../semantic-advisor/conditional-rules.js";
 import { semanticSourceHash } from "../semantic-advisor/shared.js";
 import { buildLogicApplyPlan } from "./logic-modeling.js";
 import { strictWriteSetToApplyPlan, writeSetPrimaryEntityId, } from "./requirement-applyplan.js";
@@ -196,9 +198,7 @@ export function annotateModelRequirementStep(step, context) {
                     {
                         claim_key: context.claimKey,
                         claim_text: normalizedClaimText,
-                        role: /\b(?:must|shall|should|required|requires?)\b/i.test(claimText)
-                            ? "normative"
-                            : "descriptive",
+                        role: modeledClaimRole(claimText),
                         status: "modeled",
                         span: {
                             start: 0,
@@ -211,92 +211,250 @@ export function annotateModelRequirementStep(step, context) {
     }
     return step;
 }
-export async function getWorkspaceMigrationWarning(workspaceRoot) {
-    const status = readKbManifestStatus(workspaceRoot);
-    if (status.state === "ok")
-        return null;
-    return status.warning;
+function stepProperties(step) {
+    return step.properties !== null && typeof step.properties === "object"
+        ? step.properties
+        : {};
 }
-export async function handleKbModelRequirement(_prolog, args, workspaceRoot, context) {
-    const extracted = extractRequirementClaim({
-        ...args,
-        source: normalizeOptionalString(args.source) ??
-            normalizeSourceFiles(args.sourceFiles)[0] ??
-            "mcp://kibi/model-requirement",
+// implements REQ-kibi-truthful-consistency
+function unresolvedObservationStep(step) {
+    if (step.type !== "fact")
+        return step;
+    const properties = stepProperties(step);
+    const tags = Array.isArray(properties.tags) ? properties.tags : [];
+    return {
+        ...step,
+        properties: {
+            ...properties,
+            tags: Array.from(new Set([...tags, "review:ontology-gap"])),
+        },
+    };
+}
+// implements REQ-kibi-proposition-complete-ingestion
+// The advisor decides each proposition's role, and proposition-complete
+// ingestion compares the persisted inventory with it. A rule modality alone
+// would call "X must not happen unless C" normative where the advisor reads an
+// exception, so the role comes from the advisor's own clause analysis.
+function advisorRole(semanticText, claimKey) {
+    const clause = extractSemanticClauses(semanticText).find((entry) => entry.claim_key === claimKey);
+    return clause ? propositionRole(clause.text, clause.normative) : null;
+}
+function withAdvisorRoles(plan) {
+    return plan.map((step) => {
+        if (step.type !== "req")
+            return step;
+        const properties = stepProperties(step);
+        const semanticText = properties.semantic_text;
+        const inventory = properties.semantic_inventory;
+        if (typeof semanticText !== "string" || !Array.isArray(inventory))
+            return step;
+        return {
+            ...step,
+            properties: {
+                ...properties,
+                semantic_inventory: inventory.map((entry) => {
+                    if (entry === null || typeof entry !== "object")
+                        return entry;
+                    const row = entry;
+                    const role = typeof row.claim_key === "string"
+                        ? advisorRole(semanticText, row.claim_key)
+                        : null;
+                    return role === null ? row : { ...row, role };
+                }),
+            },
+        };
     });
-    if (args.logic !== undefined) {
-        const logicPlan = buildLogicApplyPlan({
-            text: args.text,
-            logic: args.logic,
-            source: extracted.source,
-            ...(typeof args.requirementId === "string"
-                ? { requirementId: args.requirementId }
-                : {}),
-            ...(args.existingLogicClaims !== undefined
-                ? { existingLogicClaims: args.existingLogicClaims }
-                : {}),
-            ...(args.claimKey !== undefined ? { claimKey: args.claimKey } : {}),
-            ...(args.claimText !== undefined ? { claimText: args.claimText } : {}),
-        });
-        const fallbackWriteSet = buildStrictWriteSet({
-            claim: extracted.claim,
-            statement: extracted.statement,
-        });
-        const migrationWarning = await getWorkspaceMigrationWarning(workspaceRoot);
-        const structuredContent = {
-            statement: extracted.statement,
+}
+// implements REQ-kibi-logical-requirement-coverage
+async function logicModelResult(args, extracted, logic, workspaceRoot, confidence) {
+    const logicPlan = buildLogicApplyPlan({
+        text: args.text,
+        logic,
+        source: extracted.source,
+        ...(typeof args.requirementId === "string"
+            ? { requirementId: args.requirementId }
+            : {}),
+        ...(args.existingLogicClaims !== undefined
+            ? { existingLogicClaims: args.existingLogicClaims }
+            : {}),
+        ...(args.claimKey !== undefined ? { claimKey: args.claimKey } : {}),
+        ...(args.claimText !== undefined ? { claimText: args.claimText } : {}),
+    });
+    const applyPlan = withAdvisorRoles(logicPlan.applyPlan);
+    const fallbackWriteSet = buildStrictWriteSet({
+        claim: extracted.claim,
+        statement: extracted.statement,
+    });
+    const migrationWarning = await getWorkspaceMigrationWarning(workspaceRoot);
+    const structuredContent = {
+        statement: extracted.statement,
+        claimKey: logicPlan.claimKey,
+        logicClaims: Array.from(new Set([...(args.existingLogicClaims ?? []), logicPlan.claimKey])),
+        source: extracted.source,
+        sourceFiles: extracted.sourceFiles,
+        claim: extracted.claim,
+        writeSet: fallbackWriteSet,
+        applyPlan,
+        isStrict: false,
+        confidence,
+        extractionMode: extracted.extractionMode,
+        extractionWarnings: extracted.extractionWarnings,
+        warnings: [],
+        migrationWarning,
+        logic: {
+            semanticKey: logicPlan.semanticKey,
             claimKey: logicPlan.claimKey,
-            logicClaims: Array.from(new Set([...(args.existingLogicClaims ?? []), logicPlan.claimKey])),
+            claimText: logicPlan.claimText,
+            renderedProlog: logicPlan.renderedProlog,
+            normalized: logicPlan.normalized,
+        },
+    };
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Modeled typed kibi.logic.v1 rule ${logicPlan.semanticKey}; apply the returned schema, rule, and requirement steps sequentially.`,
+            },
+        ],
+        structuredContent,
+        applyPlan,
+        writeSet: fallbackWriteSet,
+        migrationWarning,
+    };
+}
+// implements REQ-kibi-truthful-consistency
+// A recognised conditional clause that cannot be translated gets no
+// observation and no strict property. With a requirementId the requirement
+// records the clause as an unresolved ontology gap in its inventory.
+async function unresolvedConditionalResult(args, extracted, reason, workspaceRoot) {
+    const semanticText = args.text.trim();
+    const claimText = normalizeSemanticClause(extracted.statement);
+    const claimKey = semanticClaimKey(claimText);
+    const logicClaims = Array.from(new Set([...(args.existingLogicClaims ?? []), claimKey]));
+    const start = Math.max(0, semanticText.indexOf(claimText));
+    const applyPlan = typeof args.requirementId === "string"
+        ? [
+            {
+                type: "req",
+                id: args.requirementId,
+                properties: {
+                    title: claimText.split(/[.!?]/, 1)[0] || "Conditional requirement",
+                    status: "open",
+                    source: extracted.source,
+                    semantic_text: semanticText,
+                    logic_claims: logicClaims,
+                    semantic_clauses: [claimText],
+                    semantic_inventory_version: "kibi.semantic-inventory.v1",
+                    semantic_source_field: "semantic_text",
+                    semantic_source_hash: semanticSourceHash(semanticText),
+                    semantic_inventory: [
+                        {
+                            claim_key: claimKey,
+                            claim_text: claimText,
+                            role: advisorRole(semanticText, claimKey) ??
+                                modeledClaimRole(claimText),
+                            status: "ontology_gap",
+                            span: {
+                                start: Buffer.byteLength(semanticText.slice(0, start), "utf8"),
+                                end: Buffer.byteLength(semanticText.slice(0, start + claimText.length), "utf8"),
+                            },
+                            reason,
+                        },
+                    ],
+                },
+                relationships: [],
+            },
+        ]
+        : [];
+    const writeSet = buildStrictWriteSet({
+        claim: extracted.claim,
+        statement: extracted.statement,
+    });
+    const migrationWarning = await getWorkspaceMigrationWarning(workspaceRoot);
+    return {
+        content: [
+            {
+                type: "text",
+                text: "Recognised a conditional requirement but could not translate it; it stays unresolved until a typed kibi.logic.v1 rule is supplied.",
+            },
+        ],
+        structuredContent: {
+            statement: extracted.statement,
+            claimKey,
+            logicClaims,
             source: extracted.source,
             sourceFiles: extracted.sourceFiles,
             claim: extracted.claim,
-            writeSet: fallbackWriteSet,
-            applyPlan: logicPlan.applyPlan,
+            writeSet,
+            applyPlan,
             isStrict: false,
-            confidence: args.confidence ?? 1,
+            confidence: 0,
             extractionMode: extracted.extractionMode,
             extractionWarnings: extracted.extractionWarnings,
-            warnings: [],
-            migrationWarning,
-            logic: {
-                semanticKey: logicPlan.semanticKey,
-                claimKey: logicPlan.claimKey,
-                claimText: logicPlan.claimText,
-                renderedProlog: logicPlan.renderedProlog,
-                normalized: logicPlan.normalized,
-            },
-        };
-        return {
-            content: [
+            warnings: [
                 {
-                    type: "text",
-                    text: `Modeled typed kibi.logic.v1 rule ${logicPlan.semanticKey}; apply the returned schema, rule, and requirement steps sequentially.`,
+                    kind: "unresolved_conditional_clause",
+                    message: `${reason} The clause stays unresolved: Kibi emitted no strict property and no observation for it.`,
+                    nextAction: "Pass logic with a kibi.logic.v1 rule that forbids the action unless the condition holds, or call kb_model with mode predicates when the condition is a domain relation, then apply the returned steps sequentially.",
                 },
             ],
-            structuredContent,
-            applyPlan: logicPlan.applyPlan,
-            writeSet: fallbackWriteSet,
             migrationWarning,
-        };
-    }
+        },
+        applyPlan,
+        writeSet,
+        migrationWarning,
+    };
+}
+export async function getWorkspaceMigrationWarning(workspaceRoot) {
+    const status = readKbManifestStatus(workspaceRoot);
+    if (status.state === "ok")
+        return null;
+    return status.warning;
+}
+export async function handleKbModelRequirement(_prolog, args, workspaceRoot, context) {
+    const extracted = extractRequirementClaim({
+        ...args,
+        source: normalizeOptionalString(args.source) ??
+            normalizeSourceFiles(args.sourceFiles)[0] ??
+            "mcp://kibi/model-requirement",
+    });
+    if (args.logic !== undefined)
+        return logicModelResult(args, extracted, args.logic, workspaceRoot, args.confidence ?? 1);
+    // implements REQ-kibi-truthful-consistency
+    // A conditional requirement ("X may happen only when C", "X must not happen
+    // unless C") restricts an action. It goes to the rule lane and never falls
+    // back to a strict property or an observation; a conditional clause this
+    // reader cannot translate stays unresolved.
+    const conditional = extracted.extractionMode === "provided"
+        ? null
+        : detectConditionalRule(extracted.statement);
+    if (conditional?.kind === "rule")
+        return logicModelResult(args, extracted, conditional.ir, workspaceRoot, args.confidence ?? 0.8);
+    if (conditional?.kind === "unparsed")
+        return unresolvedConditionalResult(args, extracted, conditional.reason, workspaceRoot);
     const claimKey = semanticClaimKey(extracted.statement);
     const aligned = await applyVocabularyAlignment(context, extracted, claimKey);
     const writeSet = aligned.writeSet;
     const logicClaims = Array.from(new Set([...(args.existingLogicClaims ?? []), claimKey]));
-    const applyPlan = aligned
-        .adjustPlan(strictWriteSetToApplyPlan(writeSet))
-        .map((step) => annotateModelRequirementStep(step, {
-        claimKey,
-        statement: extracted.statement,
-        logicClaims,
-    }));
+    const plan = aligned.adjustPlan(strictWriteSetToApplyPlan(writeSet));
+    // A strict write set grounds the claim, so its steps carry the claim. The
+    // below-threshold observation is only a review artifact: it gets no claim
+    // provenance (that would make it look like grounding) and is tagged as an
+    // open ontology gap.
+    const applyPlan = writeSet.isStrict
+        ? plan.map((step) => annotateModelRequirementStep(step, {
+            claimKey,
+            statement: extracted.statement,
+            logicClaims,
+        }))
+        : plan.map(unresolvedObservationStep);
     const migrationWarning = await getWorkspaceMigrationWarning(workspaceRoot);
     const warnings = writeSet.isStrict
         ? [...aligned.warnings]
         : [
             {
                 kind: "low_confidence_observation_downgrade",
-                message: `Claim confidence ${writeSet.confidence.toFixed(2)} is below the strict threshold 0.70, so Kibi emitted an observation fact instead of strict subject/property facts.`,
+                message: `Claim confidence ${writeSet.confidence.toFixed(2)} is below the strict threshold 0.70, so Kibi emitted a review:ontology-gap observation instead of strict subject/property facts. The clause stays unresolved: the observation does not ground it.`,
                 nextAction: "If this is normative, provide subjectKey, propertyKey, operator, and value explicitly, then apply the returned strict write-set sequentially.",
             },
         ];

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

@@ -6,6 +6,22 @@ type TransactionInput = {
     readonly skipContradictionCheck: boolean;
 };
 export declare function buildUpsertCommitGoal(input: TransactionInput): string;
+type WhatIfInput = TransactionInput & {
+    readonly relationshipsOnly?: boolean;
+};
+/**
+ * Goal that stages inputs in a rolled-back transaction and returns the
+ * contradiction witnesses the KB would then contain, as JSON in JsonString.
+ * Inputs without entity properties stage only their relationships, so a
+ * relationship-only step never erases an existing entity's properties.
+ */
+export declare function buildWhatIfContradictionGoal(inputs: readonly WhatIfInput[]): string;
+/**
+ * Goal for checks:what_if_analysis_json/2: the current and staged
+ * contradiction and scenario-infeasibility witnesses, with the
+ * introduced/removed/unchanged split, as JSON in JsonString.
+ */
+export declare function buildWhatIfAnalysisGoal(inputs: readonly WhatIfInput[]): 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">;

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;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"}
+{"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;AAiBD,KAAK,WAAW,GAAG,gBAAgB,GAAG;IAAE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAgB/E;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,SAAS,WAAW,EAAE,GAC7B,MAAM,CAER;AAGD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,WAAW,EAAE,GAC7B,MAAM,CAER;AAED,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

@@ -12,6 +12,38 @@ function upsertBatchEntry(input) {
     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"})`;
 }
+// Engines that only loaded kb.pl (one-shot processes, embedders) have not
+// loaded checks.pl yet; load it from kb.pl's directory on first use. The
+// call/1 defers resolving the checks procedure until after the load.
+const ENSURE_CHECKS_LOADED = "(current_predicate(checks:what_if_analysis_json/2) -> true ; module_property(kb, file(KbFile)), file_directory_name(KbFile, KbDir), directory_file_path(KbDir, 'checks.pl', ChecksFile), use_module(ChecksFile))";
+function whatIfEntries(inputs) {
+    const entries = inputs.map((input) => {
+        const relationships = input.relationships.map((relationship) => `rel(${String(relationship.type)}, '${escapeAtom(String(relationship.from))}', '${escapeAtom(String(relationship.to))}', ${buildRelationshipMetadata(relationship)})`);
+        if (input.relationshipsOnly === true)
+            return `relate([${relationships.join(", ")}])`;
+        return `upsert(${String(input.entity.type)}, ${buildPropertyList(input.entity)}, [${relationships.join(", ")}])`;
+    });
+    return `[${entries.join(", ")}]`;
+}
+// implements REQ-kibi-truthful-consistency
+/**
+ * Goal that stages inputs in a rolled-back transaction and returns the
+ * contradiction witnesses the KB would then contain, as JSON in JsonString.
+ * Inputs without entity properties stage only their relationships, so a
+ * relationship-only step never erases an existing entity's properties.
+ */
+export function buildWhatIfContradictionGoal(inputs) {
+    return `(${ENSURE_CHECKS_LOADED}, call(checks:what_if_contradiction_witnesses_json(${whatIfEntries(inputs)}, JsonString)))`;
+}
+// implements REQ-kibi-truthful-consistency
+/**
+ * Goal for checks:what_if_analysis_json/2: the current and staged
+ * contradiction and scenario-infeasibility witnesses, with the
+ * introduced/removed/unchanged split, as JSON in JsonString.
+ */
+export function buildWhatIfAnalysisGoal(inputs) {
+    return `(${ENSURE_CHECKS_LOADED}, call(checks:what_if_analysis_json(${whatIfEntries(inputs)}, JsonString)))`;
+}
 /** One transaction and one journal flush for a receipt campaign. */
 // implements REQ-core-atomic-upsert-persistence
 export function buildUpsertBatchCommitGoal(inputs) {

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,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"}
+{"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;AAqBvC,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,CAuSzC"}

package/dist/operations/mutation/delete.js

@@ -6,6 +6,7 @@ import { parseEntityFromList, parseListOfLists, toPrologAtom, } from "../../prol
 import { listShards, readAllShards, readShard, removeRelationshipsFromShards, renderShardWithout, } from "../../relationships/shards.js";
 import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
 import { buildEntityDeleteAuditGoal } from "./audit.js";
+import { planRecoveryNotes, settlePendingPlanApplyJournals, withPlanRecoveryNotes, } from "./plan-apply-journal.js";
 import { RELATIONSHIP_TYPES, dependentRelationshipsGoal, } from "./relationships.js";
 import { saveAtomicMutation, saveMutation } from "./save.js";
 import { normalizeAuthoredSourcePath, renderMarkdownRelationshipDeletion, renderSourceDeletion, renderYamlRelationshipDeletion, resolveContainedSourcePath, writePendingSourceReceipt, } from "./source-authoring.js";
@@ -349,9 +350,15 @@ export async function executeDelete(input, context) {
     let sourceMutationLock;
     let committed = false;
     let operationFailure;
+    let recoveryNotes = [];
+    const reported = (text) => recoveryNotes.length > 0 ? `${text} ${recoveryNotes.join(" ")}` : text;
     try {
         if (context.fs && context.sourceMutationLockHeld !== true) {
             sourceMutationLock = await acquireWorkspaceMutationLock(context.workspaceRoot);
+            // implements REQ-core-atomic-upsert-persistence
+            // Finish an interrupted kb_apply_plan before this delete reads or
+            // changes the files its journal guards.
+            recoveryNotes = planRecoveryNotes(await settlePendingPlanApplyJournals({ ...context, branchAttachment }, { prolog: async () => prolog }));
         }
         const ids = input.ids ?? [];
         const relationships = input.relationships ?? [];
@@ -367,7 +374,7 @@ export async function executeDelete(input, context) {
                 content: [
                     {
                         type: "text",
-                        text: `Deleted ${payload.relationships_deleted ?? 0} relationships. Skipped ${payload.skipped}.${payload.sync_required ? " Run kibi sync to reconcile the relationship shard." : ""}`,
+                        text: reported(`Deleted ${payload.relationships_deleted ?? 0} relationships. Skipped ${payload.skipped}.${payload.sync_required ? " Run kibi sync to reconcile the relationship shard." : ""}`),
                     },
                 ],
                 structuredContent: payload,
@@ -505,7 +512,7 @@ export async function executeDelete(input, context) {
                 content: [
                     {
                         type: "text",
-                        text: `Deletion plan ${planHash.slice(0, 12)} must be applied through kb_apply_plan.`,
+                        text: reported(`Deletion plan ${planHash.slice(0, 12)} must be applied through kb_apply_plan.`),
                     },
                 ],
                 structuredContent: payload,
@@ -533,7 +540,7 @@ export async function executeDelete(input, context) {
             content: [
                 {
                     type: "text",
-                    text: `Deleted ${payload.deleted} entities. Skipped ${payload.skipped}.${errors.length > 0 ? ` Errors: ${errors.join("; ")}` : ""}`,
+                    text: reported(`Deleted ${payload.deleted} entities. Skipped ${payload.skipped}.${errors.length > 0 ? ` Errors: ${errors.join("; ")}` : ""}`),
                 },
             ],
             structuredContent: payload,
@@ -545,15 +552,16 @@ export async function executeDelete(input, context) {
         // wrap it as non-retryable immediately instead of only when lock release
         // also fails.
         if (error instanceof OperationError || error instanceof InputError) {
-            operationFailure = { error };
-            throw error;
+            const failure = withPlanRecoveryNotes(error, recoveryNotes);
+            operationFailure = { error: failure };
+            throw failure;
         }
         if (committed) {
-            const failure = classifySourceMutationFailure("Delete", error, true);
+            const failure = withPlanRecoveryNotes(classifySourceMutationFailure("Delete", error, true), recoveryNotes);
             operationFailure = { error: failure };
             throw failure;
         }
-        const failure = new Error(`Delete execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        const failure = withPlanRecoveryNotes(new Error(`Delete execution failed: ${error instanceof Error ? error.message : String(error)}`), recoveryNotes);
         operationFailure = { error: failure };
         throw failure;
     }

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

@@ -0,0 +1,21 @@
+import type { PrologPort } from "../../public/operations/runtime-types.js";
+import type { StagedUpsertState, UpsertInput } from "./types.js";
+/**
+ * Resolve the provenance an upsert writes. kb_upsert never overwrites who
+ * authored an entity by omission:
+ *
+ * 1. A supplied `origin` is written as given (schema validation follows);
+ *    when it omits `recorded_at`, the write time is recorded.
+ * 2. Without one, an existing entity keeps its stored origin unchanged.
+ * 3. Without one, a new entity is recorded as `{kind: agent, recorded_at}`:
+ *    kb_upsert is the agent write path, and a human or import author says so
+ *    explicitly.
+ * 4. Without one, an existing entity that has no origin (authored before
+ *    schema 6, or by hand) stays without one; editing it does not make the
+ *    editor its author. `kibi migrate` backfills `kind: migration`.
+ *
+ * Without a Prolog runtime the existing entity cannot be read, so only rule 1
+ * applies.
+ */
+export declare function resolveUpsertOrigin(input: UpsertInput, prolog: Pick<PrologPort, "query"> | undefined, now: Date, staged?: StagedUpsertState): Promise<UpsertInput>;
+//# sourceMappingURL=origin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"origin.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/origin.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAUjE;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,GAAG,EAAE,IAAI,EACT,MAAM,CAAC,EAAE,iBAAiB,GACzB,OAAO,CAAC,WAAW,CAAC,CAiCtB"}

package/dist/operations/mutation/origin.js

@@ -0,0 +1,78 @@
+/*
+ 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 { escapeAtom } from "../../prolog/codec.js";
+import { readEntityOrigin } from "../../public/entity-origin.js";
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function withOrigin(input, origin) {
+    return { ...input, properties: { ...input.properties, origin } };
+}
+/**
+ * Resolve the provenance an upsert writes. kb_upsert never overwrites who
+ * authored an entity by omission:
+ *
+ * 1. A supplied `origin` is written as given (schema validation follows);
+ *    when it omits `recorded_at`, the write time is recorded.
+ * 2. Without one, an existing entity keeps its stored origin unchanged.
+ * 3. Without one, a new entity is recorded as `{kind: agent, recorded_at}`:
+ *    kb_upsert is the agent write path, and a human or import author says so
+ *    explicitly.
+ * 4. Without one, an existing entity that has no origin (authored before
+ *    schema 6, or by hand) stays without one; editing it does not make the
+ *    editor its author. `kibi migrate` backfills `kind: migration`.
+ *
+ * Without a Prolog runtime the existing entity cannot be read, so only rule 1
+ * applies.
+ */
+// implements REQ-kibi-entity-origin
+export async function resolveUpsertOrigin(input, prolog, now, staged) {
+    const supplied = input.properties.origin;
+    if (supplied !== undefined) {
+        return isRecord(supplied) && supplied.recorded_at === undefined
+            ? withOrigin(input, { ...supplied, recorded_at: now.toISOString() })
+            : input;
+    }
+    if (prolog === undefined)
+        return input;
+    // An earlier step of the same plan that writes this entity is its history.
+    const planned = staged?.entities.get(input.id);
+    if (planned !== undefined) {
+        const stored = readEntityOrigin(planned.origin);
+        return stored === null ? input : withOrigin(input, stored);
+    }
+    // The same existence probe the rest of the upsert uses.
+    const exists = await prolog.query(`once(kb_entity('${escapeAtom(input.id)}', _, _))`);
+    if (!exists.success) {
+        return withOrigin(input, { kind: "agent", recorded_at: now.toISOString() });
+    }
+    let stored = null;
+    try {
+        const [existing] = await loadEntities(prolog, {
+            id: input.id,
+            type: input.type,
+        });
+        stored = readEntityOrigin(existing?.origin);
+    }
+    catch {
+        // Unreadable: leave origin out. The source-first write merges the
+        // authored frontmatter, so a stored origin there survives either way.
+    }
+    return stored === null ? input : withOrigin(input, stored);
+}