kibi-cli 2.24.0 → 2.26.1

package/dist/firm-decision-edit.d.ts

@@ -0,0 +1,30 @@
+/** A requirement or ADR as authored: front matter and Markdown body. */
+export type DecisionDocument = Readonly<{
+    type: string;
+    data: Readonly<Record<string, unknown>>;
+    body: string;
+}>;
+/** The parts of a decision's claim an in-place edit may change. */
+export type DecisionClaimField = "title" | "statement" | "body" | "firmness";
+/**
+ * The claim fields that differ between two versions of one decision. A
+ * requirement's claim is its title, its stated meaning and the statement its
+ * body derives (context sections may change freely); an ADR's claim is its
+ * title and whole body. Lowering a firm decision's firmness changes it too.
+ */
+export declare function decisionClaimChanges(before: DecisionDocument, after: DecisionDocument): DecisionClaimField[];
+/**
+ * Whether `after` cites human words `before` did not: the reference a person
+ * gave for this change. Kibi checks that a new reference is present, not that
+ * it is genuine.
+ */
+export declare function citesNewHumanWords(before: DecisionDocument, after: DecisionDocument): boolean;
+/**
+ * The claim fields an edit changes on a firm decision without citing new
+ * human words; empty when the edit is allowed. Only a decision that is firm
+ * before the edit is guarded.
+ */
+export declare function unapprovedFirmEdit(before: DecisionDocument, after: DecisionDocument): DecisionClaimField[];
+/** What to do instead of editing a firm decision in place. */
+export declare function firmEditGuidance(type: string): string;
+//# sourceMappingURL=firm-decision-edit.d.ts.map

package/dist/firm-decision-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firm-decision-edit.d.ts","sourceRoot":"","sources":["../src/firm-decision-edit.ts"],"names":[],"mappings":"AAqBA,wEAAwE;AAExE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,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,mEAAmE;AAEnE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAC;AAiB7E;;;;;GAKG;AAEH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,gBAAgB,GACtB,kBAAkB,EAAE,CAsBtB;AAED;;;;GAIG;AAEH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAMT;AAED;;;;GAIG;AAEH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,gBAAgB,GACtB,kBAAkB,EAAE,CAStB;AAED,8DAA8D;AAE9D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/firm-decision-edit.js

@@ -0,0 +1,90 @@
+/*
+ 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 { effectiveFirmness, firmnessRef } from "./decision-firmness.js";
+import { requirementSemanticText } from "./extractors/markdown.js";
+function normalized(value) {
+    return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+}
+/**
+ * What a requirement states: its authored `semantic_text`, else the
+ * statement its body derives. Context sections are not part of it.
+ */
+function requirementStatement(document) {
+    const authored = normalized(document.data.semantic_text);
+    return authored !== ""
+        ? authored
+        : normalized(requirementSemanticText(document.body));
+}
+/**
+ * The claim fields that differ between two versions of one decision. A
+ * requirement's claim is its title, its stated meaning and the statement its
+ * body derives (context sections may change freely); an ADR's claim is its
+ * title and whole body. Lowering a firm decision's firmness changes it too.
+ */
+// implements REQ-kb-firm-decision-edit
+export function decisionClaimChanges(before, after) {
+    const changed = [];
+    if (normalized(before.data.title) !== normalized(after.data.title))
+        changed.push("title");
+    if (before.type === "req") {
+        if (requirementStatement(before) !== requirementStatement(after) ||
+            normalized(requirementSemanticText(before.body)) !==
+                normalized(requirementSemanticText(after.body)))
+            changed.push("statement");
+    }
+    else if (normalized(before.body) !== normalized(after.body)) {
+        changed.push("body");
+    }
+    if (effectiveFirmness(before.type, before.data.firmness, before.data.origin) ===
+        "firm" &&
+        effectiveFirmness(after.type, after.data.firmness, after.data.origin) !==
+            "firm")
+        changed.push("firmness");
+    return changed;
+}
+/**
+ * Whether `after` cites human words `before` did not: the reference a person
+ * gave for this change. Kibi checks that a new reference is present, not that
+ * it is genuine.
+ */
+// implements REQ-kb-firm-decision-edit
+export function citesNewHumanWords(before, after) {
+    const ref = firmnessRef({ type: after.type, ...after.data });
+    return (ref !== undefined &&
+        ref !== firmnessRef({ type: before.type, ...before.data }));
+}
+/**
+ * The claim fields an edit changes on a firm decision without citing new
+ * human words; empty when the edit is allowed. Only a decision that is firm
+ * before the edit is guarded.
+ */
+// implements REQ-kb-firm-decision-edit
+export function unapprovedFirmEdit(before, after) {
+    if (effectiveFirmness(before.type, before.data.firmness, before.data.origin) !==
+        "firm")
+        return [];
+    const changed = decisionClaimChanges(before, after);
+    if (changed.length === 0 || citesNewHumanWords(before, after))
+        return [];
+    return changed;
+}
+/** What to do instead of editing a firm decision in place. */
+// implements REQ-kb-firm-decision-edit
+export function firmEditGuidance(type) {
+    return `Ask the person who stated it. If they agree, either write the change with ${type === "req" ? "origin.ref or approval_ref" : "origin.ref"} pointing at their words, or supersede it with a new firmness: firm decision that cites them; otherwise leave it and propose the change`;
+}

package/dist/operations/bootstrap/claim-restatement.d.ts

@@ -0,0 +1,37 @@
+/** A current requirement a declared intent claim may restate. */
+export type ExistingRequirement = {
+    readonly id: string;
+    readonly title: string;
+    readonly semanticText: string;
+};
+/**
+ * Token-set Jaccard at or above which a claim that is not an exact
+ * restatement is still flagged for review: the same threshold the
+ * entity-context check uses to call a context section a restatement of the
+ * title. Below it a claim is planned with no signal.
+ */
+export declare const NEAR_RESTATEMENT_JACCARD = 0.8;
+export type RestatementMatch = {
+    /** exact: the normalized texts are equal; near: overlap at the threshold. */
+    readonly kind: "exact" | "near";
+    readonly requirementId: string;
+    /** The requirement field the claim matched. */
+    readonly field: "title" | "semantic_text";
+    /** Token-set Jaccard of the closest pair, rounded to two decimals. */
+    readonly score: number;
+};
+/**
+ * Case, whitespace and punctuation do not change what a sentence says, so
+ * they do not count when a claim is compared with a requirement.
+ */
+export declare function normalizeRestatementText(text: string): string;
+/**
+ * The current requirement a claim restates, if any. A claim restates a
+ * requirement exactly when its statement or excerpt, normalized, equals the
+ * requirement's title, its semantic text or one sentence of it; only that
+ * counts as already in the KB. A pair at or above NEAR_RESTATEMENT_JACCARD is
+ * a near restatement: a review signal, never a reason to drop the claim.
+ * Requirements are compared in id order, so the answer is deterministic.
+ */
+export declare function findRestatement(claimTexts: readonly (string | undefined)[], requirements: readonly ExistingRequirement[]): RestatementMatch | null;
+//# sourceMappingURL=claim-restatement.d.ts.map

package/dist/operations/bootstrap/claim-restatement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-restatement.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/claim-restatement.ts"],"names":[],"mappings":"AAKA,iEAAiE;AAEjE,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF;;;;;GAKG;AAEH,eAAO,MAAM,wBAAwB,MAAsB,CAAC;AAG5D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC;IAC1C,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;GAGG;AAEH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM7D;AAwBD;;;;;;;GAOG;AAEH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAC3C,YAAY,EAAE,SAAS,mBAAmB,EAAE,GAC3C,gBAAgB,GAAG,IAAI,CAoCzB"}

package/dist/operations/bootstrap/claim-restatement.js

@@ -0,0 +1,83 @@
+import { RESTATEMENT_JACCARD, tokenSetJaccard, } from "../../entity-body-context.js";
+/**
+ * Token-set Jaccard at or above which a claim that is not an exact
+ * restatement is still flagged for review: the same threshold the
+ * entity-context check uses to call a context section a restatement of the
+ * title. Below it a claim is planned with no signal.
+ */
+// implements REQ-bootstrap-claim-restatement
+export const NEAR_RESTATEMENT_JACCARD = RESTATEMENT_JACCARD;
+/**
+ * Case, whitespace and punctuation do not change what a sentence says, so
+ * they do not count when a claim is compared with a requirement.
+ */
+// implements REQ-bootstrap-claim-restatement
+export function normalizeRestatementText(text) {
+    return text
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter((token) => token !== "")
+        .join(" ");
+}
+/** The whole prose and each of its sentences. */
+function proseUnits(text) {
+    const sentences = text
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((sentence) => sentence.trim())
+        .filter((sentence) => sentence !== "");
+    return [text, ...sentences];
+}
+function references(requirement) {
+    return [
+        { field: "title", text: requirement.title },
+        ...proseUnits(requirement.semanticText).map((text) => ({
+            field: "semantic_text",
+            text,
+        })),
+    ].filter((reference) => normalizeRestatementText(reference.text) !== "");
+}
+/**
+ * The current requirement a claim restates, if any. A claim restates a
+ * requirement exactly when its statement or excerpt, normalized, equals the
+ * requirement's title, its semantic text or one sentence of it; only that
+ * counts as already in the KB. A pair at or above NEAR_RESTATEMENT_JACCARD is
+ * a near restatement: a review signal, never a reason to drop the claim.
+ * Requirements are compared in id order, so the answer is deterministic.
+ */
+// implements REQ-bootstrap-claim-restatement
+export function findRestatement(claimTexts, requirements) {
+    const texts = claimTexts
+        .filter((text) => typeof text === "string")
+        .map((text) => ({ text, normalized: normalizeRestatementText(text) }))
+        .filter((text) => text.normalized !== "");
+    if (texts.length === 0)
+        return null;
+    const ordered = [...requirements].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+    let near = null;
+    let nearScore = 0;
+    for (const requirement of ordered) {
+        for (const reference of references(requirement)) {
+            const normalized = normalizeRestatementText(reference.text);
+            for (const claim of texts) {
+                if (claim.normalized === normalized)
+                    return {
+                        kind: "exact",
+                        requirementId: requirement.id,
+                        field: reference.field,
+                        score: 1,
+                    };
+                const score = tokenSetJaccard(claim.text, reference.text);
+                if (score >= NEAR_RESTATEMENT_JACCARD && score > nearScore) {
+                    nearScore = score;
+                    near = {
+                        kind: "near",
+                        requirementId: requirement.id,
+                        field: reference.field,
+                        score: Math.round(score * 100) / 100,
+                    };
+                }
+            }
+        }
+    }
+    return near;
+}

package/dist/operations/bootstrap/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/generate.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAejF,OAAO,KAAK,EAGV,SAAS,EACT,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACzC,SAAS,gBAAgB,EAAE,CAI7B;AA+BD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd;IACD,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAClE,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAwJA;AAkMD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAqI9B"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/generate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAgBjF,OAAO,KAAK,EAGV,SAAS,EACT,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACzC,SAAS,gBAAgB,EAAE,CAI7B;AA+BD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd;IACD,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAClE,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAwJA;AAmND,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAwI9B"}

package/dist/operations/bootstrap/generate.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
-import { loadEntityIds } from "../../public/operations/discovery-entities.js";
+import { loadCurrentRequirementTexts, loadEntityIds, } from "../../public/operations/discovery-entities.js";
 import { executeStatus } from "../../public/operations/discovery-executors.js";
 import { readWorkspaceSnapshot } from "../../public/operations/workspace-snapshot.js";
 import { stagedLogicalGroundingError, } from "../semantic-advisor/ingestion-boundary.js";
@@ -238,21 +238,31 @@ function activationSuppressedClaims(declared, activation) {
         activationMode: activation.activationMode,
     }));
 }
+const NO_EXISTING_KNOWLEDGE = {
+    ids: new Set(),
+    requirements: [],
+};
 /**
  * IDs already in the KB, so declared claims and discovered candidates that
- * exist are counted under entity_exists instead of being planned again. An
- * attached root starts the lazy engine when the host supplied none (the CLI
- * does so for status anyway); an unattached root never starts one.
+ * exist are counted under entity_exists instead of being planned again, and,
+ * when intent claims are declared, the current requirements those claims may
+ * restate. An attached root starts the lazy engine when the host supplied
+ * none (the CLI does so for status anyway); an unattached root never starts
+ * one.
  */
-// implements REQ-bootstrap-intent-claim-accounting
-async function existingEntityIds(context, attached) {
+// implements REQ-bootstrap-intent-claim-accounting, REQ-bootstrap-claim-restatement
+async function existingKnowledge(context, attached, withRequirements) {
     try {
         const prolog = context.prolog ?? (attached ? await context.ensureProlog?.() : undefined);
         if (!prolog)
-            return new Set();
+            return NO_EXISTING_KNOWLEDGE;
         // Ids only: materializing every entity (receipt histories included)
         // just to build this set exceeds the bounded engine output.
-        return new Set((await loadEntityIds(prolog)).filter(Boolean));
+        const ids = new Set((await loadEntityIds(prolog)).filter(Boolean));
+        const requirements = withRequirements
+            ? await loadCurrentRequirementTexts(prolog)
+            : [];
+        return { ids, requirements };
     }
     catch (error) {
         throw new Error(`Bootstrap binding could not read existing entity IDs: ${error instanceof Error ? error.message : String(error)}`);
@@ -346,11 +356,12 @@ export async function executePlanBootstrap(args, context) {
     const maxCandidates = clamp(Math.trunc(args.maxCandidates ?? 50), 1, 200);
     const entityBindingDiagnostics = [];
     const discovery = await discoverBootstrap(context);
-    const existingIds = await existingEntityIds(context, discovery.activation.activationState === "root_active_thin" ||
-        discovery.activation.activationState === "root_active_seeded").catch((error) => {
+    const existing = await existingKnowledge(context, discovery.activation.activationState === "root_active_thin" ||
+        discovery.activation.activationState === "root_active_seeded", (declared.intentClaims?.length ?? 0) > 0).catch((error) => {
         entityBindingDiagnostics.push(error.message);
-        return new Set();
+        return NO_EXISTING_KNOWLEDGE;
     });
+    const existingIds = existing.ids;
     // Discovery runs before planning so its evidence paths can be bound into
     // the exact plan rather than leaving the reviewer to reconstruct them.
     const bound = await expectedSnapshots(context, discovery.evidence
@@ -374,7 +385,7 @@ export async function executePlanBootstrap(args, context) {
     const allowDeclaredClaims = discovery.activation.allowDeclaredClaims ??
         discovery.activation.allowCandidateGeneration;
     const claimed = allowDeclaredClaims
-        ? buildIntentClaimCandidates(declared, existingIds, minConfidence, subjectKeys)
+        ? buildIntentClaimCandidates(declared, existingIds, minConfidence, subjectKeys, existing.requirements)
         : {
             candidates: [],
             sourceOnlySignals: [],

package/dist/operations/bootstrap/intent-claims.d.ts

@@ -1,3 +1,4 @@
+import { type ExistingRequirement } from "./claim-restatement.js";
 import { type SubjectKeyRegistry } from "./requirement-claims.js";
 import type { BootstrapDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
 export type IntentClaimBuildResult = {
@@ -12,7 +13,9 @@ export type IntentClaimBuildResult = {
  * what the agent read, binds it into the plan hash through the declared
  * context, and keeps the citation on every candidate it produces. A claim the
  * strict modeler cannot ground stays an explicit authoring follow-up instead
- * of becoming unverifiable knowledge.
+ * of becoming unverifiable knowledge. An intent claim whose statement or
+ * excerpt restates a current requirement is already in the KB and is counted
+ * as such instead of being planned again under a new id.
  */
-export declare function buildIntentClaimCandidates(declared: BootstrapDeclaredContext, existingIds: ReadonlySet<string>, minConfidence: number, subjectKeys?: SubjectKeyRegistry): IntentClaimBuildResult;
+export declare function buildIntentClaimCandidates(declared: BootstrapDeclaredContext, existingIds: ReadonlySet<string>, minConfidence: number, subjectKeys?: SubjectKeyRegistry, existingRequirements?: readonly ExistingRequirement[]): IntentClaimBuildResult;
 //# sourceMappingURL=intent-claims.d.ts.map

package/dist/operations/bootstrap/intent-claims.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intent-claims.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/intent-claims.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,kBAAkB,EAGxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,wBAAwB,EAGxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAClE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAAC;AAyOF;;;;;;;GAOG;AAEH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,kBAAkB,GAC/B,sBAAsB,CA4KxB"}
+{"version":3,"file":"intent-claims.d.ts","sourceRoot":"","sources":["../../../src/operations/bootstrap/intent-claims.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,kBAAkB,EAGxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,wBAAwB,EAGxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAClE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAAC;AAuPF;;;;;;;;;GASG;AAEH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,kBAAkB,EAChC,oBAAoB,GAAE,SAAS,mBAAmB,EAAO,GACxD,sBAAsB,CA+MxB"}

package/dist/operations/bootstrap/intent-claims.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { renderRequirementBody } from "../../entity-body-context.js";
 import { buildStrictWriteSet } from "../../utils/strict-modeling.js";
 import { asImportedRule, confidenceBand, strictPlan, upsert, } from "./candidate-helpers.js";
+import { findRestatement, } from "./claim-restatement.js";
 import { claimFor, planSubjectKey, } from "./requirement-claims.js";
 /** How much a claim is trusted follows the authority the human assigned. */
 const AUTHORITY_CONFIDENCE = {
@@ -190,16 +191,27 @@ function conflictCandidates(declared, sources, existingIds, minConfidence) {
     }
     return { candidates, sourceOnlySignals: [], suppressed, diagnostics };
 }
+/**
+ * The review signal a planned claim carries when it closely restates a
+ * current requirement: kept, but named so the reviewer can drop it or link
+ * the two with restates or supersedes.
+ */
+// implements REQ-bootstrap-claim-restatement
+function nearRestatementDiagnostic(source, claim, match) {
+    return `Intent claim at ${source.id}:${claim.reference} closely restates current requirement ${match.requirementId} (token overlap ${match.score} with its ${match.field === "title" ? "title" : "semantic text"}, not an exact match); it is still planned. Review it before apply: drop the claim if it states the same rule, or keep it and link the two with restates or supersedes.`;
+}
 /**
  * Turn intent the agent harvested from declared knowledge sources into cited
  * bootstrap candidates. Kibi never contacts those sources: it only records
  * what the agent read, binds it into the plan hash through the declared
  * context, and keeps the citation on every candidate it produces. A claim the
  * strict modeler cannot ground stays an explicit authoring follow-up instead
- * of becoming unverifiable knowledge.
+ * of becoming unverifiable knowledge. An intent claim whose statement or
+ * excerpt restates a current requirement is already in the KB and is counted
+ * as such instead of being planned again under a new id.
  */
-// implements REQ-kibi-bootstrap-knowledge-sources, REQ-bootstrap-claim-kinds-and-conflicts
-export function buildIntentClaimCandidates(declared, existingIds, minConfidence, subjectKeys) {
+// implements REQ-kibi-bootstrap-knowledge-sources, REQ-bootstrap-claim-kinds-and-conflicts, REQ-bootstrap-claim-restatement
+export function buildIntentClaimCandidates(declared, existingIds, minConfidence, subjectKeys, existingRequirements = []) {
     const sources = new Map((declared.knowledgeSources ?? []).map((source) => [source.id, source]));
     const candidates = [];
     const sourceOnlySignals = [];
@@ -255,7 +267,31 @@ export function buildIntentClaimCandidates(declared, existingIds, minConfidence,
                 candidates.push(review);
             continue;
         }
-        const evidence = citation(source, claim);
+        // A claim that restates a current requirement word for word (case,
+        // whitespace and punctuation aside) is that requirement: count it as
+        // already in the KB under the requirement's id, and do not model it.
+        const restatement = findRestatement([claim.statement, claim.excerpt], existingRequirements);
+        if (restatement?.kind === "exact") {
+            suppressed.push({
+                candidateId: "",
+                reason: "entity_exists",
+                sourcePath: claim.reference,
+                entityType: "req",
+                statement: claim.statement,
+                sourceId: source.id,
+                matchedId: restatement.requirementId,
+                matchedBy: "restatement",
+                matchedField: restatement.field,
+            });
+            continue;
+        }
+        const nearRestatement = restatement?.kind === "near" ? restatement : null;
+        const evidence = [
+            ...citation(source, claim),
+            ...(nearRestatement
+                ? [`possible_restatement:${nearRestatement.requirementId}`]
+                : []),
+        ];
         const provenance = `${source.id}:${claim.reference}`;
         let writeSet = null;
         try {
@@ -301,6 +337,8 @@ export function buildIntentClaimCandidates(declared, existingIds, minConfidence,
                     ? withClaimBody(asImportedRule(withRationale(step, claim.rationale), provenance), claimBody(source, claim))
                     : step),
             });
+            if (nearRestatement)
+                diagnostics.push(nearRestatementDiagnostic(source, claim, nearRestatement));
             continue;
         }
         if (writeSet?.isStrict && confidence < minConfidence)
@@ -326,6 +364,8 @@ export function buildIntentClaimCandidates(declared, existingIds, minConfidence,
             confidence,
             evidence,
         });
+        if (nearRestatement)
+            diagnostics.push(nearRestatementDiagnostic(source, claim, nearRestatement));
     }
     const declaredConflicts = conflictCandidates(declared, sources, existingIds, minConfidence);
     return {

package/dist/operations/migration/requirement-status.d.ts

@@ -5,6 +5,17 @@ import { type InventoryRederivation } from "./inventory-rederive.js";
  * intent is `closed`.
  */
 export declare const SUGGESTED_REQUIREMENT_STATUS: Readonly<Record<string, string>>;
+/** The tag that keeps a delivered legacy requirement's meaning once closed. */
+export declare const DELIVERED_REQUIREMENT_TAG = "implemented";
+/**
+ * Legacy delivery statuses and their one lossless current reading: `closed`
+ * with the tag `implemented`, which kb.pl reads as a delivered requirement
+ * that still owes coverage. `kibi migrate` applies these without review.
+ */
+export declare const DELIVERED_REQUIREMENT_STATUS: Readonly<Record<string, Readonly<{
+    status: string;
+    tag: string;
+}>>>;
 /** One requirement whose status is outside the vocabulary. */
 export type RequirementStatusFinding = Readonly<{
     requirementId: string;
@@ -12,6 +23,19 @@ export type RequirementStatusFinding = Readonly<{
     status: string;
     /** The suggested current status; null when Kibi has no suggestion. */
     suggestedStatus: string | null;
+    /**
+     * The lossless mapping `kibi migrate` applies without review (delivery
+     * vocabulary); null when the target status is a person's choice.
+     */
+    automatic: Readonly<{
+        status: string;
+        tag: string;
+    }> | null;
+    /**
+     * Why `kibi sync` cannot compile the requirement as authored (for example
+     * a status outside the entity schema); null when it compiles.
+     */
+    extractionError: string | null;
     /** Inventory drift the requirement shows once it has the suggested status. */
     latentDrift: InventoryRederivation | null;
 }>;
@@ -19,7 +43,22 @@ export type RequirementStatusFinding = Readonly<{
 export declare function planRequirementStatusMappings(workspaceRoot: string): RequirementStatusFinding[];
 /**
  * Set the status of one requirement from `from` to `to`, replacing only its
- * `status` line. Refuses when the authored status is no longer `from`.
+ * `status` line, and add `tag` when given and missing. Refuses when the
+ * authored status is no longer `from`.
+ */
+export declare function applyRequirementStatusMapping(workspaceRoot: string, relativePath: string, from: string, to: string, tag?: string): void;
+/** What mapping the delivery statuses changed, and what it could not edit. */
+export type DeliveredStatusMappingResult = Readonly<{
+    mapped: readonly RequirementStatusFinding[];
+    skipped: readonly Readonly<{
+        path: string;
+        reason: string;
+    }>[];
+}>;
+/**
+ * Map every requirement whose status is delivery vocabulary to `closed` with
+ * the tag `implemented`, front matter only. With `only`, maps just those
+ * requirement ids (a plan action applies what it planned). Idempotent.
  */
-export declare function applyRequirementStatusMapping(workspaceRoot: string, relativePath: string, from: string, to: string): void;
+export declare function applyDeliveredStatusMappings(workspaceRoot: string, only?: ReadonlySet<string>): DeliveredStatusMappingResult;
 //# sourceMappingURL=requirement-status.d.ts.map

package/dist/operations/migration/requirement-status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requirement-status.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/requirement-status.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,yBAAyB,CAAC;AA8BjC;;;;GAIG;AAEH,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOzE,CAAC;AAEF,8DAA8D;AAE9D,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,8EAA8E;IAC9E,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC3C,CAAC,CAAC;AAYH,yEAAyE;AAEzE,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,GACpB,wBAAwB,EAAE,CA8B5B;AAED;;;GAGG;AAEH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,IAAI,CAaN"}
+{"version":3,"file":"requirement-status.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/requirement-status.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,yBAAyB,CAAC;AAkCjC;;;;GAIG;AAEH,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOzE,CAAC;AAEF,+EAA+E;AAE/E,eAAO,MAAM,yBAAyB,gBAAgB,CAAC;AAEvD;;;;GAIG;AAEH,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CACjD,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAK1D,CAAC;AAEF,8DAA8D;AAE9D,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,SAAS,EAAE,QAAQ,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IAC5D;;;OAGG;IACH,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,8EAA8E;IAC9E,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC3C,CAAC,CAAC;AAqBH,yEAAyE;AAEzE,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,GACpB,wBAAwB,EAAE,CAkC5B;AASD;;;;GAIG;AAEH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,GAAG,CAAC,EAAE,MAAM,GACX,IAAI,CAiBN;AAED,8EAA8E;AAE9E,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,MAAM,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAC5C,OAAO,EAAE,SAAS,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CAChE,CAAC,CAAC;AAEH;;;;GAIG;AAEH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,4BAA4B,CAuB9B"}

package/dist/operations/migration/requirement-status.js

@@ -16,6 +16,8 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 import path from "node:path";
+import { extractFromMarkdown } from "../../extractors/markdown.js";
+import { withAddedTag } from "./entity-body-context.js";
 import { planInventoryRederivation, } from "./inventory-rederive.js";
 import { listLaneMarkdownFiles, readText, readTopLevelField, sliceFrontmatter, withTopLevelField, writeFileAtomically, } from "./kb-sources.js";
 /**
@@ -25,8 +27,12 @@ import { listLaneMarkdownFiles, readText, readTopLevelField, sliceFrontmatter, w
  * it is not a current requirement: the proof ladder skips it and the
  * ingestion boundary does not validate its semantic inventory, so inventory
  * drift stays hidden until someone maps the status. Which current status a
- * legacy one means is a semantic choice, so the mapping is only suggested;
- * the latent drift is computed as if the suggestion were applied.
+ * legacy one means is usually a semantic choice, so the mapping is only
+ * suggested; the latent drift is computed as if the suggestion were applied.
+ * Delivery vocabulary (`implemented`, `done`, `completed`) has one lossless
+ * reading, `closed` plus the tag `implemented`, and is mapped automatically:
+ * those statuses are outside the entity schema, so `kibi sync` cannot
+ * compile such a requirement at all until it is mapped.
  */
 /** Statuses `kibi check` accepts on a requirement (canonical and legacy). */
 const REQUIREMENT_STATUSES = new Set([
@@ -50,6 +56,29 @@ export const SUGGESTED_REQUIREMENT_STATUS = {
     superseded: "closed",
     rejected: "closed",
 };
+/** The tag that keeps a delivered legacy requirement's meaning once closed. */
+// implements REQ-cli-schema-migration
+export const DELIVERED_REQUIREMENT_TAG = "implemented";
+/**
+ * Legacy delivery statuses and their one lossless current reading: `closed`
+ * with the tag `implemented`, which kb.pl reads as a delivered requirement
+ * that still owes coverage. `kibi migrate` applies these without review.
+ */
+// implements REQ-cli-schema-migration
+export const DELIVERED_REQUIREMENT_STATUS = {
+    implemented: { status: "closed", tag: DELIVERED_REQUIREMENT_TAG },
+    done: { status: "closed", tag: DELIVERED_REQUIREMENT_TAG },
+    completed: { status: "closed", tag: DELIVERED_REQUIREMENT_TAG },
+};
+function extractionErrorOf(absolutePath) {
+    try {
+        extractFromMarkdown(absolutePath);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 function statusOf(content) {
     const slice = sliceFrontmatter(content);
     return slice === null ? undefined : readTopLevelField(slice.text, "status");
@@ -73,12 +102,15 @@ export function planRequirementStatusMappings(workspaceRoot) {
         const requirementId = typeof id === "string" && id.length > 0
             ? id
             : path.basename(file.relativePath, ".md");
-        const suggestedStatus = SUGGESTED_REQUIREMENT_STATUS[status] ?? null;
+        const automatic = DELIVERED_REQUIREMENT_STATUS[status] ?? null;
+        const suggestedStatus = automatic?.status ?? SUGGESTED_REQUIREMENT_STATUS[status] ?? null;
         findings.push({
             requirementId,
             path: file.relativePath,
             status,
             suggestedStatus,
+            automatic,
+            extractionError: extractionErrorOf(file.absolutePath),
             latentDrift: suggestedStatus === null
                 ? null
                 : (planInventoryRederivation(workspaceRoot, requirementId, {
@@ -88,18 +120,54 @@ export function planRequirementStatusMappings(workspaceRoot) {
     }
     return findings.sort((left, right) => left.requirementId.localeCompare(right.requirementId));
 }
+function hasTag(content, tag) {
+    const slice = sliceFrontmatter(content);
+    const tags = slice === null ? undefined : readTopLevelField(slice.text, "tags");
+    return Array.isArray(tags) && tags.includes(tag);
+}
 /**
  * Set the status of one requirement from `from` to `to`, replacing only its
- * `status` line. Refuses when the authored status is no longer `from`.
+ * `status` line, and add `tag` when given and missing. Refuses when the
+ * authored status is no longer `from`.
  */
 // implements REQ-cli-schema-migration
-export function applyRequirementStatusMapping(workspaceRoot, relativePath, from, to) {
+export function applyRequirementStatusMapping(workspaceRoot, relativePath, from, to, tag) {
     const absolute = path.join(workspaceRoot, relativePath);
     const content = readText(absolute);
     if (content === null || statusOf(content) !== from)
         throw new Error(`${relativePath} no longer has status ${from}; rerun kibi migrate and approve the new plan.`);
-    const next = withTopLevelField(content, "status", to);
+    const mapped = withTopLevelField(content, "status", to);
+    const next = mapped === null || tag === undefined || hasTag(mapped, tag)
+        ? mapped
+        : withAddedTag(mapped, tag);
     if (next === null)
-        throw new Error(`${relativePath}: status could not be set to ${to} without changing other frontmatter fields; set it by hand.`);
+        throw new Error(`${relativePath}: status could not be set to ${to}${tag === undefined ? "" : ` with tag ${tag}`} without changing other frontmatter fields; set it by hand.`);
     writeFileAtomically(absolute, next);
 }
+/**
+ * Map every requirement whose status is delivery vocabulary to `closed` with
+ * the tag `implemented`, front matter only. With `only`, maps just those
+ * requirement ids (a plan action applies what it planned). Idempotent.
+ */
+// implements REQ-cli-schema-migration
+export function applyDeliveredStatusMappings(workspaceRoot, only) {
+    const mapped = [];
+    const skipped = [];
+    for (const finding of planRequirementStatusMappings(workspaceRoot)) {
+        if (finding.automatic === null)
+            continue;
+        if (only !== undefined && !only.has(finding.requirementId))
+            continue;
+        try {
+            applyRequirementStatusMapping(workspaceRoot, finding.path, finding.status, finding.automatic.status, finding.automatic.tag);
+            mapped.push(finding);
+        }
+        catch (error) {
+            skipped.push({
+                path: finding.path,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { mapped, skipped };
+}