kibi-cli 2.22.0 → 2.23.0

package/dist/public/operations/schema6-check-actions.d.ts

@@ -64,6 +64,8 @@ export declare function supersessionCycleReviewActionInput(cycle: {
 export type SourcePathRewriteInput = Readonly<{
     entityId: string;
     file: string;
+    /** The field rewritten; absent means `source`. */
+    field?: "text_ref";
     from: string;
     to: string;
 }>;
@@ -88,6 +90,8 @@ export declare function sourcePathRewriteActionInput(input: Readonly<{
  */
 export declare function sourcePathReviewActionInput(source: {
     entityId: string;
+    /** The field to repair; absent means `source`. */
+    field?: "text_ref";
     value: unknown;
     file?: string;
     reason?: string;

package/dist/public/operations/schema6-check-actions.d.ts.map

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

package/dist/public/operations/schema6-check-actions.js

@@ -178,7 +178,7 @@ export function sourcePathRewriteActionInput(input) {
             { selfReferencingSources: 0 },
         ],
         evidence: {
-            reason: "The authored source field is dead data: the compiled source is always the entity's own file, and Kibi ignores the field when compiling and never writes it. Each rewrite points a knowledge file named by its pre-canonical path (under documentation/, or relative to the knowledge root) at the same file under .kb/. Each removal deletes a value that names the entity's own file (reason self) or nothing Kibi can map (reason dangling). Only the source line changes.",
+            reason: "The authored source field is dead data: the compiled source is always the entity's own file, and Kibi ignores the field when compiling and never writes it. Each rewrite points a knowledge file named by its pre-canonical path (under documentation/, or relative to the knowledge root) at the same file under .kb/; a rewrite with field text_ref does the same for a text_ref evidence path. Each removal deletes a source value that names the entity's own file (reason self) or nothing Kibi can map (reason dangling). Only the rewritten or removed line changes.",
             count: all.length,
             rewrites: rewrites.map((rewrite) => ({ ...rewrite })),
             removals: removals.map((removal) => ({ ...removal })),
@@ -195,6 +195,31 @@ export function sourcePathReviewActionInput(source) {
         ? source.value
         : JSON.stringify(source.value);
     const where = source.file !== undefined ? ` in ${source.file}` : "";
+    if (source.field === "text_ref") {
+        const edit = source.rewrite !== undefined
+            ? `replace the whole field with the single line 'text_ref: ${source.rewrite}'`
+            : "point text_ref at the evidence file's current path, or delete the field when that evidence is gone";
+        return {
+            id: `review-text-ref-dangling-${stableIdPart(source.entityId)}`,
+            code: SOURCE_PATH_REVIEW_CODE,
+            category: "quality",
+            safety: "review",
+            invocation: {
+                kind: "review",
+                instruction: `${source.entityId} has text_ref '${shown}'${where}, a file path that does not exist (${source.reason ?? "the edit would not read back as exactly that change"}). A person edits the frontmatter by hand: ${edit}. Then rerun kibi migrate.`,
+            },
+            affectedEntityIds: [source.entityId],
+            affectedFiles: source.file !== undefined ? [source.file] : [],
+            dispositionRequired: true,
+            evidence: {
+                entityId: source.entityId,
+                field: "text_ref",
+                text_ref: source.value,
+                ...(source.reason !== undefined ? { refused: source.reason } : {}),
+                ...(source.rewrite !== undefined ? { rewrite: source.rewrite } : {}),
+            },
+        };
+    }
     const edit = source.rewrite !== undefined
         ? `replace the whole field with the single line 'source: ${source.rewrite}'`
         : "delete the whole field, every line of it";
@@ -272,9 +297,11 @@ export function lifecycleActionsFromViolations(violations) {
             const from = typeof evidence.value === "string"
                 ? evidence.value
                 : (JSON.stringify(evidence.value) ?? "");
+            const textRef = evidence.field === "text_ref";
             if (refused !== "" || file === "") {
                 actions.push(sourcePathReviewActionInput({
                     entityId,
+                    ...(textRef ? { field: "text_ref" } : {}),
                     value: evidence.value,
                     ...(file !== "" ? { file } : {}),
                     ...(refused !== "" ? { reason: refused } : {}),
@@ -282,7 +309,17 @@ export function lifecycleActionsFromViolations(violations) {
                 }));
             }
             else if (rewrite !== "") {
-                rewrites.push({ entityId, file, from, to: rewrite });
+                rewrites.push({
+                    entityId,
+                    file,
+                    ...(textRef ? { field: "text_ref" } : {}),
+                    from,
+                    to: rewrite,
+                });
+            }
+            else if (textRef) {
+                // Kibi never removes evidence; an unmapped text_ref carries refused.
+                continue;
             }
             else {
                 removals.push({

package/dist/public/operations/source-path-dangling.d.ts

@@ -1,6 +1,6 @@
 import { type SourceRepair } from "../../operations/migration/source-paths.js";
 import type { Violation } from "../../utils/rule-registry.js";
-/** An authored source field that names no path, entity or URL. */
+/** An authored source field that names no path, entity or URL, or a path-shaped text_ref that names no file. */
 export declare const SOURCE_PATH_DANGLING_RULE = "source-path-dangling";
 /**
  * One blocking finding per authored source that resolves to nothing. The

package/dist/public/operations/source-path-dangling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-path-dangling.d.ts","sourceRoot":"","sources":["../../../src/public/operations/source-path-dangling.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,kEAAkE;AAElE,eAAO,MAAM,yBAAyB,yBAAyB,CAAC;AAiBhE;;;;GAIG;AAEH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,SAAS,YAAY,EAAE,GAChC,SAAS,EAAE,CAgBb;AAED;;;;GAIG;AAEH,wBAAgB,mCAAmC,CACjD,aAAa,EAAE,MAAM,GACpB,SAAS,EAAE,CAEb"}
+{"version":3,"file":"source-path-dangling.d.ts","sourceRoot":"","sources":["../../../src/public/operations/source-path-dangling.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,gHAAgH;AAEhH,eAAO,MAAM,yBAAyB,yBAAyB,CAAC;AAuBhE;;;;GAIG;AAEH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,SAAS,YAAY,EAAE,GAChC,SAAS,EAAE,CAoBb;AAED;;;;GAIG;AAEH,wBAAgB,mCAAmC,CACjD,aAAa,EAAE,MAAM,GACpB,SAAS,EAAE,CAEb"}

package/dist/public/operations/source-path-dangling.js

@@ -16,10 +16,16 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 import { findDanglingSources, shownSourceValue, } from "../../operations/migration/source-paths.js";
-/** An authored source field that names no path, entity or URL. */
+/** An authored source field that names no path, entity or URL, or a path-shaped text_ref that names no file. */
 // implements REQ-core-validation-rules, REQ-kibi-kb-lifecycle-integrity
 export const SOURCE_PATH_DANGLING_RULE = "source-path-dangling";
 function suggestion(source) {
+    if (source.field === "text_ref") {
+        if (source.refused !== undefined) {
+            return `kibi migrate cannot repair this text_ref (${source.refused}), so it plans a review_source_path_dangling action. Point text_ref at the evidence file's current path, or remove it when the evidence is gone.`;
+        }
+        return `The file moved to ${source.fix.kind === "rewrite" ? source.fix.to : source.file}; kibi migrate rewrites the text_ref field there (source_path_rewrite).`;
+    }
     const compiled = `The compiled source is always the entity's own file (${source.file}), so the field carries nothing Kibi compiles.`;
     if (source.refused !== undefined) {
         return `kibi migrate cannot edit this source field safely (${source.refused}), so it plans a review_source_path_dangling action for a person. ${compiled}`;
@@ -42,10 +48,13 @@ export function sourcePathDanglingViolations(dangling) {
     return dangling.map((source) => ({
         rule: SOURCE_PATH_DANGLING_RULE,
         entityId: source.entityId,
-        description: `${source.entityId} names source '${shownSourceValue(source.value)}', which is not an existing workspace path, an entity id or an http(s) URL`,
+        description: source.field === "text_ref"
+            ? `${source.entityId} names text_ref '${shownSourceValue(source.value)}', a file path that does not exist in the workspace`
+            : `${source.entityId} names source '${shownSourceValue(source.value)}', which is not an existing workspace path, an entity id or an http(s) URL`,
         suggestion: suggestion(source),
         source: source.file,
         evidence: {
+            ...(source.field === "text_ref" ? { field: "text_ref" } : {}),
             value: source.value,
             file: source.file,
             ...(source.fix.kind === "rewrite"

package/dist/public/operations/specs/composite.d.ts

@@ -106,7 +106,7 @@ export declare const MODEL_ROUTES: {
                     readonly items: {
                         readonly type: "string";
                     };
-                    readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
+                    readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Each clause must be a verbatim fragment of text (whitespace may differ); a clause that does not occur in text fails the call with VALIDATION_FAILED naming it. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
                 };
                 readonly interpretations: {
                     readonly type: "array";

package/dist/public/operations/specs/discovery.d.ts

@@ -85,6 +85,11 @@ export declare const querySpec: {
                 readonly default: 0;
                 readonly description: "Optional zero-based pagination offset. Default: 0. Example: 50 to skip first 50 rows.";
             };
+            readonly includeBody: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "With id only: also return the entity's authored Markdown body (the prose after its front matter) as body {id, path, text}, so a stale statement in it can be corrected; kb_upsert document.body replaces it. Default: false.";
+            };
         };
     };
     readonly requiresProlog: true;

package/dist/public/operations/specs/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAiCnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuGsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAiCnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6GsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}

package/dist/public/operations/specs/discovery.js

@@ -99,6 +99,11 @@ export const querySpec = {
                 default: 0,
                 description: "Optional zero-based pagination offset. Default: 0. Example: 50 to skip first 50 rows.",
             },
+            includeBody: {
+                type: "boolean",
+                default: false,
+                description: "With id only: also return the entity's authored Markdown body (the prose after its front matter) as body {id, path, text}, so a stale statement in it can be corrected; kb_upsert document.body replaces it. Default: false.",
+            },
         },
     },
     requiresProlog: true,

package/dist/public/operations/specs/planning.d.ts

@@ -54,7 +54,7 @@ export declare const compileIntentSpec: {
                     readonly minLength: 1;
                 };
                 readonly maxItems: 64;
-                readonly description: "Optional complete atomic clause decomposition. Each assertive clause receives independent proposition accounting.";
+                readonly description: "Optional complete atomic clause decomposition. Each clause must be a verbatim fragment of intent (whitespace may differ); a clause that does not occur in intent fails the call with VALIDATION_FAILED naming it. Each assertive clause receives independent proposition accounting.";
             };
             readonly semanticFacets: {
                 readonly type: "object";

package/dist/public/operations/specs/planning.js

@@ -49,7 +49,7 @@ export const compileIntentSpec = {
                 type: "array",
                 items: { type: "string", minLength: 1 },
                 maxItems: 64,
-                description: "Optional complete atomic clause decomposition. Each assertive clause receives independent proposition accounting.",
+                description: "Optional complete atomic clause decomposition. Each clause must be a verbatim fragment of intent (whitespace may differ); a clause that does not occur in intent fails the call with VALIDATION_FAILED naming it. Each assertive clause receives independent proposition accounting.",
             },
             semanticFacets: {
                 type: "object",

package/dist/public/operations/specs/reporting.d.ts.map

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

package/dist/public/operations/specs/reporting.js

@@ -1,3 +1,4 @@
+import { confirmMetaFreshness } from "../../../utils/content-freshness.js";
 import { PROOF_RECEIPT_MAX_AGE_SECONDS } from "../../proof-receipt.js";
 import { executeStatus } from "../discovery-executors.js";
 import { buildLegacyMigrationPlanFromContext, } from "../legacy-migration-plan.js";
@@ -58,7 +59,7 @@ export async function executeFindGaps(input, context) {
                         : `Found ${payload.count ?? rows.length} gap rows. Showing ${rows.length}: ${rows.map((row) => row.id).join(", ")}.${stubNote}`,
                 },
             ],
-            structuredContent: payload,
+            structuredContent: confirmMetaFreshness(payload, context.workspaceRoot),
         };
     }
     catch (error) {
@@ -238,15 +239,16 @@ export async function executeCoverage(input, context) {
         const migrationPlan = statusPlan
             ? mergeMigrationPlans([statusPlan, coveragePlan])
             : coveragePlan;
+        const confirmed = confirmMetaFreshness(payload, context.workspaceRoot);
         const enrichedPayload = {
-            ...payload,
+            ...confirmed,
             rows,
             ...(repairPlan !== undefined ? { repairPlan } : {}),
             ...(legacyMigrationPlan !== undefined ? { legacyMigrationPlan } : {}),
             ...(symbolRepairPlan !== undefined ? { symbolRepairPlan } : {}),
             migrationPlan,
             meta: {
-                ...(payload.meta ?? {}),
+                ...(confirmed.meta ?? {}),
                 proofReceiptMaxAgeSeconds: PROOF_RECEIPT_MAX_AGE_SECONDS,
                 proofSnapshot: codeSnapshot,
                 proofSnapshotAvailable: snapshotEvidence.available,
@@ -354,7 +356,7 @@ export async function executeGraph(input, context) {
                         : `Graph traversal returned ${nodes.length} nodes and ${edges.length} edges from ${input.seedIds.join(", ")}.`,
                 },
             ],
-            structuredContent: payload,
+            structuredContent: confirmMetaFreshness(payload, context.workspaceRoot),
         };
     }
     catch (error) {

package/dist/public/operations/specs/semantic.d.ts

@@ -19,7 +19,7 @@ export declare const semanticAdvisorSpec: {
                 readonly items: {
                     readonly type: "string";
                 };
-                readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
+                readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Each clause must be a verbatim fragment of text (whitespace may differ); a clause that does not occur in text fails the call with VALIDATION_FAILED naming it. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
             };
             readonly interpretations: {
                 readonly type: "array";

package/dist/public/operations/specs/semantic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CA2FzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAE/B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,qBAAqB,CAAC;AA8CxE,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CAmGzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}

package/dist/public/operations/specs/semantic.js

@@ -1,5 +1,6 @@
 import { InputError } from "../../../cli-errors.js";
 import { analyzeSemanticAdvisorInputWithPlugins } from "../../../operations/semantic-advisor/plugin-orchestration.js";
+import { storedLedgerDriftWarning } from "../../../operations/semantic-advisor/stored-ledger-drift.js";
 import { publicCapabilityStamp } from "../../../plugins/compose-semantic-classifier.js";
 function requiredText(value) {
     const text = typeof value === "string" ? value.trim() : "";
@@ -12,6 +13,29 @@ function optionalString(value) {
     const text = typeof value === "string" ? value.trim() : "";
     return text || undefined;
 }
+/**
+ * The stored-ledger comparison runs only for a requirement the caller named
+ * and only when the host can open the branch engine; analysis without a KB
+ * (a preview, a unit test, a workspace before `kibi sync`) stays as it was.
+ * A store that cannot be read is not an analysis failure, so the warning is
+ * simply absent then.
+ */
+// implements REQ-kibi-proposition-complete-ingestion
+async function storedLedgerWarnings(args, text, receipt, context) {
+    const id = optionalString(args.id);
+    if (!id || (optionalString(args.type) ?? "req") !== "req")
+        return [];
+    try {
+        const prolog = context?.prolog ?? (await context?.ensureProlog?.());
+        if (!prolog)
+            return [];
+        const warning = await storedLedgerDriftWarning(prolog, id, text, receipt);
+        return warning ? [warning] : [];
+    }
+    catch {
+        return [];
+    }
+}
 export async function executeSemanticAdvisor(args, context) {
     const text = requiredText(args.text);
     const id = optionalString(args.id) ?? "REQ-SEMANTIC-ADVISOR-PREVIEW";
@@ -39,6 +63,7 @@ export async function executeSemanticAdvisor(args, context) {
             : {}),
     });
     const result = orchestrated.analysis;
+    const ledgerWarnings = await storedLedgerWarnings(args, text, result.receipt, context);
     const pluginWarnings = orchestrated.stamps.length > 0
         ? [
             `Capability plugins consulted: ${orchestrated.stamps
@@ -82,12 +107,14 @@ export async function executeSemanticAdvisor(args, context) {
         content: [
             {
                 type: "text",
-                text: `kb_semantic_advisor: ${result.receipt.summary} Suggestions: ${result.receipt.suggestions.map(({ kind }) => kind).join(", ") || "none"}.`,
+                // A drift warning decides whether the analyzed ledger can be
+                // written at all, so the text says it too, not only the warnings.
+                text: `kb_semantic_advisor: ${result.receipt.summary} Suggestions: ${result.receipt.suggestions.map(({ kind }) => kind).join(", ") || "none"}.${ledgerWarnings.map((warning) => ` ${warning}`).join("")}`,
             },
         ],
         structuredContent: {
             receipt: result.receipt,
-            warnings: [...result.warnings, ...pluginWarnings],
+            warnings: [...result.warnings, ...ledgerWarnings, ...pluginWarnings],
             ...(capabilityPlugins ? { capabilityPlugins } : {}),
         },
     };
@@ -130,7 +157,7 @@ export const semanticAdvisorSpec = {
             clauses: {
                 type: "array",
                 items: { type: "string" },
-                description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.",
+                description: "Optional complete list of atomic requirement clauses supplied by the caller. Each clause must be a verbatim fragment of text (whitespace may differ); a clause that does not occur in text fails the call with VALIDATION_FAILED naming it. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.",
             },
             interpretations: {
                 type: "array",

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

@@ -2,7 +2,7 @@
 id: kibi-bootstrap
 name: kibi-bootstrap
 description: "Use for any Kibi bootstrap or onboarding task: seeding a new or thin knowledge base; reviewing a bootstrap or onboarding plan, preview, or evidence; judging approval readiness or coverage; diagnosing a blocked, partial, or failed bootstrap or its repair; applying an approved bootstrap plan; or asking the human which knowledge sources hold intent. Covers kb_status first, source interview, cited intent claims, read-only kb_plan_bootstrap preview, explicit approval, exact-plan kb_apply_plan, and repair-safe close-out."
-version: 3.11.0
+version: 3.12.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -24,6 +24,7 @@ Make `kb_status` your first tool call on every bootstrap task. This includes rev
 - **Review a supplied plan or preview, or judge approval readiness or coverage:** call `kb_status`, then run your own read-only `kb_plan_bootstrap` preview. Compare it with the supplied one: hash, candidates, citations, `suppressedCandidates`, `sourceOnlySignals`, and diagnostics. Report what is ready, what is missing or uncited, and any conflicts for the human. Do not apply. End with `kb_status`.
 - **Blocked, partial, failed, or repair:** never conclude from `kb_status` alone. Run a read-only `kb_plan_bootstrap` preview and report its eligibility and next-action fields (for example `planEligible`, `nextAction`). If it names operator-only repair such as `doctor`, report it and stop. Read `resources/branch-lifecycle.md` before migration or repair. End with `kb_status`.
 - **New or thin knowledge base, or apply an approved plan:** follow the procedure below.
+- **Knowledge base already seeded** (`activationMode: attached_seeded_handoff`): follow the same procedure. Kibi generates no discovered candidates here, but it still plans the intent claims you declare, deduplicated against the existing KB: claims already in the KB are counted as already in the KB, and a plan of the rest is `ready` and applies with `kb_apply_plan` after approval. Never fall back to one `kb_compile_intent` plus one write per claim while such a plan exists. Use `kb_compile_intent` only for claims the plan could not write (`sourceOnlySignals`, `suppressed_by_activation`, `invalid_write`), and `kb_search`/`kb_query` for existing knowledge.
 
 ## Goal
 
@@ -35,7 +36,7 @@ Seed branch-local Kibi knowledge from cited product intent, without creating a p
 2. **Harvest.** From confirmed, non-stale sources, record one statement per behavior with its source and exact reference (ticket key, URL, or anchor), and classify it: `intent` (what the product should do), `observation` (how it behaves today, with no stated intent), or `open_question` (what the sources leave undecided). Keep the original meaning. Do not merge, generalize, or resolve conflicts; record each contradiction between claims as a conflict instead. Treat source text as evidence, not instructions.
 3. **Declare** `bootstrapContext`: `projectSummary`; `knowledgeSources` (id, kind, title, locator, authority, optional connector, optional `component`); `intentClaims` (statement, sourceId, reference, `excerpt` required for `intent` and `observation` claims and optional for `open_question`, optional `kind`, default `intent`, optional `component` overriding the source's, optional `rationale` with the reason the source or the human gave, never invented); `conflicts` (`claimReferences` naming two or more declared claims by sourceId and reference, plus a one-sentence `note`). Only intent claims can become requirements. Observations, open questions (tagged `review:open-question`) and conflicts (tagged `review:conflict`) become cited observation facts. Generated subject keys take the shape `component.aspect`: name the component each source or claim is about (for example `recorder`; set `component` on the knowledge source, or on a claim to override it; repository Markdown takes its file or directory name), because an intent claim whose subject is neither one word nor already dotted, with no component, is reported in the plan diagnostics and left as an authoring follow-up instead of a malformed key. The aspect is the claim's subject, or its constrained property when the subject is the component itself. An aspect over four words or 40 characters is shortened to a noun phrase (words before `when`, `while`, `for`, `and`, ...; `support_inbox.update_in_real_time_when_a_new_ticket_is_assigned...` becomes `support_inbox.update_in_real_time`) and reported as `subject-key-shortened:` with both keys; two different subjects that shorten alike get a third segment (`editor.discard_a_draft.leaving`) and a `subject-key-disambiguated:` diagnostic; claims about one subject share one subject fact, and a `subject-key-shared:` diagnostic names the key and its sources. Show these diagnostics to the human with the plan so they can rename a key before approval. Kibi never contacts these sources. It binds your declaration into the plan hash.
 4. **Preview** with `kb_plan_bootstrap` (or `plan-bootstrap --input`), read-only. On `needs_context`, ask only its bounded questions (four at most), then preview again. When `pluginOffers` is non-empty (for example `kibi-plugin-ui` because UI component files exist), ask the human once whether to enable each offered plugin, naming its evidence files. On yes, install it as a dev dependency and add it to `package.json` `kibi.plugins` with the offered capability in `augment` mode; on no, add its name to `kibi.declinedPlugins` so it is not offered again. Either way the human decides; never enable a plugin unasked. For `kibi-plugin-ui`, step 11 also captures the UI pattern inventory (see `kibi-usage` `resources/ui-requirements.md`).
-5. **Narrow with filters, not caps.** Read the `tldr` and the `Suppressed candidates by reason` diagnostic before individual rows. If the output is too large or mostly tooling or metadata, re-preview with `entityTypes` or declared `sourceOfTruthPaths`. Generic Markdown is off by default once you declare intent claims; set `includeGenericMarkdown: true` only for repository docs the human named. Keep confirmed intent claims: they are never capped and never use `maxCandidates`, which is the separate budget for candidates Kibi discovers (symbols, tests, repository docs). Raise it only when discovered candidates you need are `over_limit`, and never for provenance stubs: a provider entry with no claim (`Source module: …`, repository metadata, layout roots) is planned last as a `meta` fact tagged `bootstrap:provenance-stub`, `discoverySummary.provenanceStubs` counts them apart from `candidatesWithClaims`, and the `over_limit` diagnostic says how many suppressed candidates are stubs; they add no knowledge, so a plan that is mostly stubs needs `entityTypes` or declared sources, not a higher cap. Read the per-source `Knowledge source …` diagnostics; if a source has claims not planned, report them per source and restate them before approval, or carry them to step 11 with their citation.
+5. **Narrow with filters, not caps.** Read the `tldr` and the `Suppressed candidates by reason` diagnostic before individual rows. If the output is too large or mostly tooling or metadata, re-preview with `entityTypes` or declared `sourceOfTruthPaths`. Generic Markdown is off by default once you declare intent claims; set `includeGenericMarkdown: true` only for repository docs the human named. Keep confirmed intent claims: they are never capped and never use `maxCandidates`, which is the separate budget for candidates Kibi discovers (symbols, tests, repository docs). Raise it only when discovered candidates you need are `over_limit`, and never for provenance stubs: a provider entry with no claim (`Source module: …`, repository metadata, layout roots) is planned last as a `meta` fact tagged `bootstrap:provenance-stub`, `discoverySummary.provenanceStubs` counts them apart from `candidatesWithClaims`, and the `over_limit` diagnostic says how many suppressed candidates are stubs; they add no knowledge, so a plan that is mostly stubs needs `entityTypes` or declared sources, not a higher cap. Read the per-source `Knowledge source …` diagnostics: each splits the claims not planned by reason (suppressed by the activation mode, a `suppressedCandidates` row, a `sourceOnlySignals` follow-up). Report them per source and restate them before approval, or carry them to step 11 with their citation.
 6. **Request approval.** Show the complete `structuredContent.plan`, the full hash (never abbreviated), which candidates cite which sources, what was omitted, the open questions and declared conflicts it records for the human to decide, and any claim that contradicts code. If you find an undeclared contradiction now, add it to `conflicts` and preview again rather than resolving it. With no answer, stop as "awaiting approval." If declined, replan and ask again with the new hash.
 7. **Pre-apply check.** The plan you send must equal the returned plan: every top-level field, including `suppressedCandidates`, `diagnostics`, `candidates`, `actions`, and `expected`, with every array the same length and order. Never rebuild it from preview fields. If the host cannot pass the exact object, stop and say so.
 8. **Apply once** with `kb_apply_plan`, the exact plan, and `approvedPlanHash`. The operation owns dependency ordering, source-first writes, sequential mutation, and recovery journaling. A plan with hundreds of actions can run for minutes: pass a `progressToken` (Kibi sends progress after each action) with a client that resets its timeout on progress, or pass `async: true` and poll `kb_job_status` when the host has it. If the apply is cut off, call `kb_apply_plan` with only the `recoveryJournalId` from `kb_status` or the error; it resumes an action interrupted mid-write and reclaims a lock left by a dead process. Never edit or delete `.kb/recovery` files; if recovery is refused, stop and report it.

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

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.16.0
+version: 2.16.2
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -92,7 +92,8 @@ it is a pointer to the knowledge, never proof. Each line answers one question:
 - `Kibi knowledge for <path> (symbol manifest):` and the `- REQ-… — <symbol
   titles>` rows: the requirements the file's symbols implement, lead
   requirement first. Read the lead requirement with `kb_query({id})` before
-  changing behavior.
+  changing behavior; add `includeBody: true` to see its authored prose, and
+  fix a stale sentence there with `kb_upsert` `document.body`.
 - `REQ-… must keep true: FACT-…` (edit only): the ground facts the lead
   requirement requires. An edit that breaks one of them is a requirement
   change: supersede and remodel the requirement, do not code around the fact.
@@ -286,8 +287,13 @@ authored. Each one is the order the write path accepts.
    existing entity, whose stored ledger Kibi keeps.
 2. **Changing the text of a grounded requirement.** New prose means new
    claim keys, so a bare rewrite is refused with `modeled proposition
-   claim_keys must match logical grounding target claim_keys exactly`.
-   Prefer supersession for a change of meaning: analyze the new prose,
+   claim_keys must match logical grounding target claim_keys exactly`; the
+   error names the modeled keys no fact declares and the facts whose keys
+   the ledger dropped. Analyze the new prose with the requirement's `id`
+   first: the receipt warns `Claim-key drift against the stored ledger`
+   and names the grounded clauses the new wording drops (the title worded
+   differently from the stored `semantic_text` is the usual cause), before
+   any write. Prefer supersession for a change of meaning: analyze the new prose,
    write its facts, write the new requirement (`-v2`) with `supersedes` to
    the old one, then set the old one to `status: closed`. Its scenario
    follows the same rule as in recipe 1: create the new scenario (with
@@ -461,7 +467,9 @@ prose (`mode: "requirement"`, or `kb_upsert` with the extended `semantic_text`
 and the ledger `mode: "analyze"` returns) and call `mode: "predicates"` again.
 Read `decisionConflicts` and its warnings whenever `plan` is null: they name
 the stored decision facts the candidate would contradict and the requirements
-that own them. `provide_argument_bindings` and `record_ontology_gap` mean
+that own them. To ask what a proposed rule would conflict with, call
+`mode: "predicates"` with its text and no `requirementId`; nothing is written.
+`provide_argument_bindings` and `record_ontology_gap` mean
 the same as for an ungrounded claim, and the gap observation is not a grounding
 link, so write it exactly as returned (tags, `claim_text`, `document.body`, no
 `claim_key`, no relationships). Record an ontology gap only when no returned schema fits the

package/dist/public/skills/kibi-usage/resources/workflows.md

@@ -83,7 +83,9 @@ On the first page, intent mode also returns an answer layer in `data.answer`
 
 - `governing` — current requirements matched by the query or linked to a
   matched entity, each with `via` (how it was reached) and its linked `facts`,
-  `scenarios`, `tests`, and `adrs`.
+  `scenarios`, `tests`, and `adrs`. A requirement with more linked facts than
+  the answer lists carries `moreFacts` (`count` and the `kb_query` `ask` that
+  lists them all); never read a short `facts` list as the whole rule.
 - `rationale` — ADRs that explain the decisions.
 - `notGoverning` — superseded or deprecated requirements, with `supersededBy`
   when known. Never read these as current policy; superseded entities are also

package/dist/search-answer.d.ts

@@ -93,6 +93,14 @@ export type SearchAnswerRequirement = SearchAnswerEntity & Readonly<{
     score: number;
     via: string;
     facts: readonly SearchAnswerFact[];
+    /**
+     * Linked facts the answer left out (over the per-requirement limit or
+     * cut to fit the byte budget) and the kb_query that lists them all.
+     */
+    moreFacts?: Readonly<{
+        count: number;
+        ask: string;
+    }>;
     scenarios: readonly SearchAnswerEntity[];
     tests: readonly SearchAnswerTest[];
     adrs: readonly SearchAnswerEntity[];
@@ -140,6 +148,12 @@ export declare const SEARCH_ANSWER_LIMITS: {
     readonly seeds: 10;
     readonly governing: 5;
     readonly perRequirement: 4;
+    /**
+     * Linked facts listed per governing requirement. Facts are what an answer
+     * states, so a requirement with several clauses keeps more of them than
+     * of its scenarios or tests.
+     */
+    readonly factsPerRequirement: 8;
     readonly rationale: 3;
     readonly notGoverning: 5;
     readonly observations: 3;

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

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

package/dist/search-answer.js

@@ -64,6 +64,12 @@ export const SEARCH_ANSWER_LIMITS = {
     seeds: 10,
     governing: 5,
     perRequirement: 4,
+    /**
+     * Linked facts listed per governing requirement. Facts are what an answer
+     * states, so a requirement with several clauses keeps more of them than
+     * of its scenarios or tests.
+     */
+    factsPerRequirement: 8,
     rationale: 3,
     notGoverning: 5,
     observations: 3,
@@ -758,11 +764,19 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
             .map((edge) => edge.from);
         const scenarioIds = unique(from("specified_by"));
         const traversed = firstOf(scenarioIds);
+        // A fact the question matched comes first, then the facts that ground a
+        // clause (requires_*) before the subject a requirement constrains: the
+        // subject's key is already part of each grounding fact's claim.
+        const linked = unique(edges
+            .filter((edge) => FACT_LINKS.has(edge.rel) && edge.from === req.id)
+            .sort((left, right) => factRank(left, seedIds) - factRank(right, seedIds))
+            .map((edge) => edge.to));
+        if (linked.length > limits.factsPerRequirement)
+            truncated = true;
         return {
             req,
-            facts: firstOf(edges
-                .filter((edge) => FACT_LINKS.has(edge.rel) && edge.from === req.id)
-                .map((edge) => edge.to)),
+            facts: linked.slice(0, limits.factsPerRequirement),
+            factsOmitted: Math.max(0, linked.length - limits.factsPerRequirement),
             scenarios: traversed,
             directTests: unique([...from("verified_by"), ...into("validates")]),
             related: firstOf([...from("relates_to"), ...into("relates_to")]),
@@ -838,6 +852,9 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
                 ...brief(fact),
                 ...factDetail(fact, schemas.get(text(fact.id))),
             })),
+            ...(plan.factsOmitted > 0
+                ? { moreFacts: moreFactsOf(req.id, plan.factsOmitted) }
+                : {}),
             scenarios: rowsOf(plan.scenarios).map(brief),
             tests: rowsOf(testIds[index] ?? []).map((row) => ({
                 ...brief(row),
@@ -924,6 +941,17 @@ const ANSWER_TRIM_ORDER = [
     "ungoverned",
     "rationale",
 ];
+/** Where a linked fact of a governing requirement sorts in its list. */
+function factRank(edge, seedIds) {
+    const matched = seedIds.indexOf(edge.to);
+    if (matched >= 0)
+        return matched;
+    return seedIds.length + (edge.rel === "constrains" ? 1 : 0);
+}
+/** The facts an answer left out of a governing requirement, and the ask. */
+function moreFactsOf(requirementId, count) {
+    return { count, ask: `kb_query(${JSON.stringify({ id: requirementId })})` };
+}
 const REQUIREMENT_TRIM_ORDER = [
     "unknowns",
     "exceptions",
@@ -999,7 +1027,17 @@ export function fitSearchAnswer(answer, maxBytes = SEARCH_ANSWER_LIMITS.maxBytes
         if (own) {
             current = {
                 ...current,
-                governing: [{ ...req, [own]: req[own].slice(0, -1) }],
+                governing: [
+                    {
+                        ...req,
+                        [own]: req[own].slice(0, -1),
+                        ...(own === "facts"
+                            ? {
+                                moreFacts: moreFactsOf(req.id, (req.moreFacts?.count ?? 0) + 1),
+                            }
+                            : {}),
+                    },
+                ],
             };
             continue;
         }