kibi-cli 2.15.0 → 2.16.0

package/dist/public/operations/specs/check-rules.generated.js

@@ -14,6 +14,7 @@ export const SELECTABLE_RULE_NAMES = [
     "symbol-traceability",
     "no-dangling-refs",
     "source-relationship-parity",
+    "branch-store-not-compiled",
     "source-path-dangling",
     "no-cycles",
     "required-fields",
@@ -58,4 +59,4 @@ export const SELECTABLE_RULE_NAMES = [
 ];
 // implements REQ-006
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, policy-ownership, policy-markers";
+export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, policy-ownership, policy-markers";

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

@@ -12,7 +12,7 @@ export declare const checkSpec: {
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, policy-ownership, policy-markers. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, policy-ownership, policy-markers. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";

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

@@ -7,10 +7,23 @@ import type { OperationResult } from "../types.js";
  * and the composite tool always agree.
  */
 type Executor = (input: never, context: OperationContext) => Promise<unknown>;
-export declare function dispatchComposite(selector: "action" | "mode", routes: Readonly<Record<string, {
+type CompositeRoute = {
+    readonly name?: string;
     readonly execute: Executor;
     readonly businessInputSchema: Readonly<Record<string, unknown>>;
-}>>, input: Readonly<Record<string, unknown>>, context: OperationContext): Promise<OperationResult<Record<string, unknown>>>;
+};
+/**
+ * A composite accepts every route's parameters, so a parameter of another
+ * route passes schema validation and the chosen route silently ignores it.
+ * Name each one instead, with the parameter this route uses for the same
+ * thing when there is one.
+ */
+export declare function foreignParameterWarnings(selector: "action" | "mode", choice: string, routes: Readonly<Record<string, CompositeRoute>>, rest: Readonly<Record<string, unknown>>): Array<{
+    parameter: string;
+    message: string;
+    nextAction: string;
+}>;
+export declare function dispatchComposite(selector: "action" | "mode", routes: Readonly<Record<string, CompositeRoute>>, input: Readonly<Record<string, unknown>>, context: OperationContext): Promise<OperationResult<Record<string, unknown>>>;
 export declare const SKILL_ROUTES: {
     readonly list: {
         readonly name: "kb_skills_list";
@@ -212,7 +225,7 @@ export declare const MODEL_ROUTES: {
                 };
                 readonly requirementId: {
                     readonly type: "string";
-                    readonly description: "Optional existing requirement ID to receive the requires_rule relationship.";
+                    readonly description: "Optional requirement ID. The strict write set updates this requirement instead of minting a REQ-AUTO id, and a typed logic rule attaches its requires_rule relationship to it.";
                 };
                 readonly claimKey: {
                     readonly type: "string";

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

@@ -1 +1 @@
-{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/composite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAMlE;;;;;GAKG;AACH,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAkB9E,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAC3B,MAAM,EAAE,QAAQ,CACd,MAAM,CACJ,MAAM,EACN;IACE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACjE,CACF,CACF,EACD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CA+BnD;AAGD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAC;AAGX,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAC;AAGX,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;CAqBW,CAAC;AAGnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;CAwBY,CAAC"}
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/composite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAMlE;;;;;GAKG;AACH,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAkB9E,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACjE,CAAC;AAmBF;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,EAChD,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CA+BnE;AAED,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAC3B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,EAChD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAuEnD;AAGD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAC;AAGX,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAC;AAGX,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;CAqBW,CAAC;AAGnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;CAwBY,CAAC"}

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

@@ -11,6 +11,51 @@ function requiredFields(spec) {
     const required = spec.businessInputSchema.required;
     return Array.isArray(required) ? required : [];
 }
+/**
+ * Per route, the parameters another route of the same composite owns that
+ * mean the same thing here under another name. kb_model mode requirement
+ * takes the claim's subject as subjectKey; mode predicates takes it as
+ * subjectHint.
+ */
+const EQUIVALENT_PARAMETERS = {
+    kb_suggest_predicates: { subjectKey: "subjectHint" },
+    kb_model_requirement: { subjectHint: "subjectKey" },
+};
+/** Routed operations whose `warnings` are `{ kind, message, nextAction }`. */
+const RECORD_WARNING_OPERATIONS = new Set(["kb_model_requirement"]);
+// implements REQ-kibi-mcp-tool-consolidation
+/**
+ * A composite accepts every route's parameters, so a parameter of another
+ * route passes schema validation and the chosen route silently ignores it.
+ * Name each one instead, with the parameter this route uses for the same
+ * thing when there is one.
+ */
+export function foreignParameterWarnings(selector, choice, routes, rest) {
+    const route = routes[choice];
+    if (route === undefined)
+        return [];
+    const own = new Set(Object.keys(properties(route)));
+    const equivalents = route.name === undefined ? {} : (EQUIVALENT_PARAMETERS[route.name] ?? {});
+    const warnings = [];
+    for (const parameter of Object.keys(rest)) {
+        if (own.has(parameter) || rest[parameter] === undefined)
+            continue;
+        const owners = Object.entries(routes)
+            .filter(([other, otherRoute]) => other !== choice && parameter in properties(otherRoute))
+            .map(([other]) => `${selector}: ${other}`);
+        if (owners.length === 0)
+            continue;
+        const equivalent = equivalents[parameter];
+        warnings.push({
+            parameter,
+            message: `${parameter} is a ${owners.join(" / ")} argument; ${selector}: ${choice} ignored it.`,
+            nextAction: equivalent !== undefined
+                ? `Use ${equivalent} in ${selector}: ${choice}.`
+                : `Drop ${parameter}, or switch to ${owners.join(" / ")} if that is what you meant.`,
+        });
+    }
+    return warnings;
+}
 export async function dispatchComposite(selector, routes, input, context) {
     const choice = input[selector];
     const route = typeof choice === "string" ? routes[choice] : undefined;
@@ -33,9 +78,41 @@ export async function dispatchComposite(selector, routes, input, context) {
     const content = wrapped && Array.isArray(result.content)
         ? result.content
         : [{ type: "text", text: `${selector} ${String(choice)} completed` }];
+    const ignored = foreignParameterWarnings(selector, String(choice), routes, rest);
+    if (ignored.length === 0) {
+        return {
+            content,
+            structuredContent: { [selector]: choice, ...payload },
+        };
+    }
+    // The routed payload's own warnings list carries them, in its own shape;
+    // a payload without one gets them in the text content only.
+    const asRecords = route.name !== undefined && RECORD_WARNING_OPERATIONS.has(route.name);
+    const routedWarnings = Array.isArray(payload.warnings)
+        ? {
+            warnings: [
+                ...payload.warnings,
+                ...ignored.map((warning) => asRecords
+                    ? {
+                        kind: "parameter_ignored",
+                        message: warning.message,
+                        nextAction: warning.nextAction,
+                    }
+                    : `${warning.message} ${warning.nextAction}`),
+            ],
+        }
+        : {};
     return {
-        content,
-        structuredContent: { [selector]: choice, ...payload },
+        content: [
+            ...content,
+            {
+                type: "text",
+                text: ignored
+                    .map((warning) => `${warning.message} ${warning.nextAction}`)
+                    .join("\n"),
+            },
+        ],
+        structuredContent: { [selector]: choice, ...payload, ...routedWarnings },
     };
 }
 // implements REQ-kibi-mcp-tool-consolidation

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

@@ -61,7 +61,7 @@ export declare const modelRequirementSpec: {
             };
             readonly requirementId: {
                 readonly type: "string";
-                readonly description: "Optional existing requirement ID to receive the requires_rule relationship.";
+                readonly description: "Optional requirement ID. The strict write set updates this requirement instead of minting a REQ-AUTO id, and a typed logic rule attaches its requires_rule relationship to it.";
             };
             readonly claimKey: {
                 readonly type: "string";

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

@@ -56,7 +56,7 @@ export const modelRequirementSpec = {
             },
             requirementId: {
                 type: "string",
-                description: "Optional existing requirement ID to receive the requires_rule relationship.",
+                description: "Optional requirement ID. The strict write set updates this requirement instead of minting a REQ-AUTO id, and a typed logic rule attaches its requires_rule relationship to it.",
             },
             claimKey: {
                 type: "string",

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.10.0
+version: 3.11.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -46,6 +46,7 @@ Seed branch-local Kibi knowledge from cited product intent, without creating a p
     - **Scenarios.** Write scenarios from the cited ticket's acceptance criteria, one scenario per criterion, not bulk drafts from the requirement title; ask the human when the source states none. Give each a plain title, the scenario prose in `document.body` (never in `properties`), and `assumes` links to the `property_value` facts whose values the scenario relies on. Set `expects` only when the scenario links `assumes` facts (or its criterion names concrete values that become them); `expects` without `assumes` only yields a feasibility-unknown warning, so a draft tagged `needs-human-review` omits `expects`. Then link the requirement with `specified_by` (upsert the `req` with its stored `title`, a `status` and that relationship only). Example: criterion "Given an annotation in draft state, when the user deletes it, the draft is cleared" becomes `{"type":"scenario","id":"SCEN-annotation-delete-clears-draft","properties":{"title":"Deleting a draft annotation clears the draft","status":"active","expects":"success"},"document":{"body":"Given an annotation in draft state, when the user deletes it, then the draft is cleared and nothing is published.\n\nThe acceptance criterion comes from the cited ticket; reviewers asked for it so a deleted draft never reappears after reload.\n"},"relationships":[{"type":"assumes","from":"SCEN-annotation-delete-clears-draft","to":"FACT-annotation-state-draft"}]}`, where the assumed fact is a `property_value` (`annotation.state` `eq` `draft`). Link existing tests that exercise it; never invent test evidence.
     - **Predicates.** Run `kb_model` with `mode: "predicates"` and `requirementId` on each persisted requirement and apply a returned plan with `requires_predicate` to its `relationshipTarget` (the planned `FACT-PRED-…` id, never a `SUGGEST-…` candidate id), or record the `review:ontology-gap` observation it returns, with its prose in `document.body`. A non-empty `existingGrounding` means the bootstrap already grounded that claim: on `replace_grounding` leave it unless the human wants the `replacementPlan` swap; on `provide_argument_bindings` retry with the listed arguments bound; on `record_ontology_gap` still write the returned gap observation, which is not a grounding link. Count what `kb_query` shows afterwards, not the calls you made.
     - **Unrecorded ambiguity.** Record any conflict or open question you found but did not declare in step 3 as a cited `fact_kind: observation` tagged `review:conflict` or `review:open-question`.
+    - **Proof integration.** Run `kibi proof inspect --json`. When it returns an `integrationPlan` (a `command` integration for the detected test runner), show the human the proposed command and `contractDefaults`, and on approval apply that exact plan with `kb_apply_plan` (`plan`, `approvedPlanHash` = its `planHash`, `approvedActionIds`); it writes `.kb/proof/integrations.json`, which you never hand-write. With no runner detected, report that proof stays deferred. Proof-bearing tests then name the integration in `proof_contract.integration`, and `kibi prove` records their evidence.
     Finish with `kb_check` and `kb_status`.
 12. **Report** calls made, result statuses, applied scope, what step 11 authored, gaps, and follow-ups. Classify as complete, partial, awaiting approval, or blocked.
 

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.11.0
+version: 2.12.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -219,11 +219,19 @@ authored. Each one is the order the write path accepts.
    `semantic_inventory_version`, `semantic_source_field` and
    `semantic_source_hash`, the prose into `semantic_text`, `propositions`
    into `semantic_inventory` and the assertive `claim_key`s into
-   `logic_claims`. `kb_model` mode `predicates` per clause; `kb_upsert` the
-   returned `applyPlan` fact first (it carries the clause's `claim_key`).
-   Then write the requirement in one `kb_upsert` with the ledger (that
-   clause `status: modeled`), a sectioned `document.body`, `constrains` to
-   the subject fact and `requires_predicate` to `relationshipTarget`. A
+   `logic_claims`. Reuse (or `kb_upsert`) the subject fact, then call
+   `kb_model` mode `predicates` per clause with `subjectHint` set to that
+   subject fact's `subject_key`: the requirement constrains nothing yet, so
+   the hint is the planned subject and the planned fact gets its
+   `subject_key` (`subjectKey` is a mode `requirement` parameter; mode
+   `predicates` ignores it and warns). `kb_upsert` the returned `applyPlan`
+   fact first (it carries the clause's `claim_key`). Then write the
+   requirement in one `kb_upsert` with the ledger (that clause `status:
+   modeled`), a sectioned `document.body`, `constrains` to the subject
+   fact, `requires_predicate` to `relationshipTarget` and `specified_by` to
+   its scenario: `specified_by` (req → scenario) is sent in the
+   requirement's write, never in the scenario's, so create the scenario
+   first. A
    `modeled` entry and its grounding link must arrive in the same write
    (`modeled semantic_inventory entries (n) must equal logical grounding
    relationships (m)`); a clause not grounded yet stays `status: missing`

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

@@ -54,7 +54,16 @@ Provenance lives in `proof_bindings`; the contract stays semantic.
 ## Integration configuration
 
 `.kb/proof/integrations.json` (`kibi.proof-integration.v1`) is tracked,
-Kibi-managed configuration describing evidence production only:
+Kibi-managed configuration describing evidence production only. Never
+hand-write it: `kibi proof inspect --json` proposes a `command` integration
+for the detected test runner (the `package.json` `test` script first) and
+returns `integrationPlan`, a hash-bound `kibi.migration-plan.v2`, plus the
+`contractDefaults` a proof-bearing test's `proof_contract` uses. Show the
+proposal to the human, then apply the plan with `kb_apply_plan` (or
+`kibi apply-plan --input -`) passing `plan`, `approvedPlanHash` (the plan's
+`planHash`) and `approvedActionIds`. Once the file exists, a create plan is
+refused; `kibi proof inspect --update <id> --json` plans adding or replacing
+one named integration.
 
 - `producer: command` — Kibi synthesizes the envelope from the process
   outcome; obligations are bound with `aggregate_run` provenance and the
@@ -82,8 +91,11 @@ effective fingerprint and do.
 
 ## Common rejections
 
-- `No proof integration configuration` — bootstrap has not configured proof
-  for this repository yet; do not hand-wave, run the bootstrap proof step.
+- `No proof integration configuration` — proof is not configured for this
+  repository yet; run `kibi proof inspect --json`, review its
+  `integrationPlan` and apply it with `kb_apply_plan`.
+- `integration '<id>' ... is not configured` — the test names an integration
+  the file lacks; plan it with `kibi proof inspect --update <id> --json`.
 - `captured snapshot is not the live workspace snapshot` — the tree changed
   between capture and ingest; re-run `kibi prove`.
 - `artifact command_argv does not match the configured command` — the

package/dist/utils/branch-store.d.ts

@@ -1,3 +1,7 @@
+/** Stale-reason code of a branch store that was never compiled. */
+export declare const BRANCH_STORE_NOT_COMPILED = "branch_store_not_compiled";
+/** The kb_check rule that reports it. */
+export declare const BRANCH_STORE_NOT_COMPILED_RULE = "branch-store-not-compiled";
 export type BranchStoreState = "healthy" | "missing" | "incomplete" | "unreadable";
 export type BranchStoreInspection = Readonly<{
     state: BranchStoreState;
@@ -18,4 +22,32 @@ export declare function inspectBranchStore(workspaceRoot: string, branch: string
  */
 export declare function storeLockJournalReason(storePath: string): Record<string, unknown> | null;
 export declare function branchStoreReason(inspection: BranchStoreInspection): Record<string, unknown> | null;
+/**
+ * The number of authored source files under `.kb/`: entity Markdown in the
+ * entity lanes plus relationship shards. Filesystem only, like
+ * inspectBranchStore, so a status read never compiles anything.
+ */
+export declare function countAuthoredKbSources(workspaceRoot: string): number;
+export type BranchStoreCompilation = Readonly<{
+    /** True once a sync (or any write) has committed into the store. */
+    compiled: boolean;
+    /** The journal CURRENT pointer (`generation-<id>:<sequence>`), if any. */
+    generation: string | null;
+}>;
+/**
+ * Whether the branch store holds a compilation. A missing store holds none;
+ * a journaled store whose CURRENT sequence is still 0 and whose journal holds
+ * no graph data was created (by `kibi branch ensure` or by an engine
+ * attaching to a new branch) but nothing was ever committed into it, so it is
+ * empty. A legacy kb.rdf store counts as compiled.
+ */
+export declare function branchStoreCompilation(inspection: BranchStoreInspection): BranchStoreCompilation;
+/**
+ * The single blocking reason for a branch whose store was never compiled
+ * while `.kb/` holds authored sources: Kibi stores are per branch and never
+ * copied, so a fresh branch (no post-checkout hook) starts empty. Every
+ * check against that store would report each authored relationship as
+ * missing; the one fix is `kibi sync`.
+ */
+export declare function uncompiledBranchStoreReason(workspaceRoot: string, inspection: BranchStoreInspection, branch: string): Record<string, unknown> | null;
 //# sourceMappingURL=branch-store.d.ts.map

package/dist/utils/branch-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,qBAAqB,CA0GvB;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAiBhC;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC"}
+{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AAwBA,mEAAmE;AACnE,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,yCAAyC;AACzC,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,qBAAqB,CA0GvB;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAiBhC;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC;AA6BD;;;;GAIG;AAEH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,qBAAqB,GAChC,sBAAsB,CAwBxB;AAkBD;;;;;;GAMG;AAEH,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAwBhC"}

package/dist/utils/branch-store.js

@@ -2,10 +2,15 @@
  Kibi — repo-local, per-branch, queryable long-term memory for software projects
  Copyright (C) 2026 Piotr Franczyk
 */
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync, } from "node:fs";
 import * as path from "node:path";
 import { classifyStoreLockHolder, readStoreLockOwner, } from "../prolog/store-lock.js";
 import { branchStoreManifestMatches, branchStorePath, legacyBranchStorePath, } from "./branch-store-locator.js";
+import { ENTITY_LANES, KB_ROOT } from "./kb-paths.js";
+/** Stale-reason code of a branch store that was never compiled. */
+export const BRANCH_STORE_NOT_COMPILED = "branch_store_not_compiled";
+/** The kb_check rule that reports it. */
+export const BRANCH_STORE_NOT_COMPILED_RULE = "branch-store-not-compiled";
 /**
  * Performs only filesystem checks. It deliberately never starts the engine or
  * attaches Prolog, so callers can still explain a broken branch store.
@@ -155,3 +160,119 @@ export function branchStoreReason(inspection) {
             : { command_argv: ["kibi", "branch", "ensure"], applyRequired: false },
     };
 }
+/** Directories under .kb/ that hold authored, Git-tracked entity sources. */
+const AUTHORED_SOURCE_DIRECTORIES = [
+    ...ENTITY_LANES.map((lane) => [lane, ".md"]),
+    ["adrs", ".md"],
+    ["relationships", ".yaml"],
+];
+function countFiles(directory, extension) {
+    let count = 0;
+    let entries;
+    try {
+        entries = readdirSync(directory, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            count += countFiles(path.join(directory, entry.name), extension);
+        }
+        else if (entry.isFile() && entry.name.endsWith(extension)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * The number of authored source files under `.kb/`: entity Markdown in the
+ * entity lanes plus relationship shards. Filesystem only, like
+ * inspectBranchStore, so a status read never compiles anything.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function countAuthoredKbSources(workspaceRoot) {
+    const kbRoot = path.join(workspaceRoot, KB_ROOT);
+    return AUTHORED_SOURCE_DIRECTORIES.reduce((total, [directory, extension]) => total + countFiles(path.join(kbRoot, directory), extension), 0);
+}
+/**
+ * Whether the branch store holds a compilation. A missing store holds none;
+ * a journaled store whose CURRENT sequence is still 0 and whose journal holds
+ * no graph data was created (by `kibi branch ensure` or by an engine
+ * attaching to a new branch) but nothing was ever committed into it, so it is
+ * empty. A legacy kb.rdf store counts as compiled.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function branchStoreCompilation(inspection) {
+    if (inspection.state === "missing") {
+        return { compiled: false, generation: null };
+    }
+    const currentPath = path.join(inspection.path, "CURRENT");
+    let current = "";
+    try {
+        current = existsSync(currentPath)
+            ? readFileSync(currentPath, "utf8").trim()
+            : "";
+    }
+    catch {
+        current = "";
+    }
+    if (current === "") {
+        // A healthy store without CURRENT is a legacy kb.rdf store.
+        return { compiled: inspection.state === "healthy", generation: null };
+    }
+    const sequence = Number(current.split(":").at(-1));
+    return {
+        compiled: (Number.isFinite(sequence) && sequence > 0) ||
+            journalHoldsGraphData(inspection.path),
+        generation: current,
+    };
+}
+/**
+ * Whether the journal directory holds persisted graph data. An empty store
+ * has only `rdf/lock`; a store migrated from a legacy kb.rdf holds the
+ * imported graph under a fresh `generation-…:0` pointer, so it is compiled
+ * although its sequence is still 0.
+ */
+function journalHoldsGraphData(storePath) {
+    try {
+        return readdirSync(path.join(storePath, "rdf")).some((entry) => entry !== "lock" && !entry.startsWith("."));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The single blocking reason for a branch whose store was never compiled
+ * while `.kb/` holds authored sources: Kibi stores are per branch and never
+ * copied, so a fresh branch (no post-checkout hook) starts empty. Every
+ * check against that store would report each authored relationship as
+ * missing; the one fix is `kibi sync`.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function uncompiledBranchStoreReason(workspaceRoot, inspection, branch) {
+    if (inspection.state !== "healthy" && inspection.state !== "missing") {
+        return null;
+    }
+    const compilation = branchStoreCompilation(inspection);
+    if (compilation.compiled)
+        return null;
+    const authoredSources = countAuthoredKbSources(workspaceRoot);
+    if (authoredSources === 0)
+        return null;
+    const storeState = inspection.state === "missing"
+        ? "does not exist yet"
+        : `is empty (${compilation.generation ?? "no generation"}: nothing compiled)`;
+    return {
+        code: BRANCH_STORE_NOT_COMPILED,
+        path: inspection.path,
+        entityIds: [],
+        detail: `The KB store for branch ${branch} ${storeState}, while .kb/ holds ${authoredSources} authored source file(s). Kibi compiles one store per branch and never copies another branch's, so every query and check reads an empty KB until this branch is compiled.`,
+        remediation: { command_argv: ["kibi", "sync"], applyRequired: false },
+        blocking: true,
+        authoredSources,
+        ...(compilation.generation !== null
+            ? { generation: compilation.generation }
+            : {}),
+    };
+}

package/dist/utils/rule-registry.generated.d.ts

@@ -23,6 +23,11 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "Authored Markdown and relationship-shard edges must exactly match the compiled KB";
     readonly enforcementClass: "canonical";
     readonly category: "integrity";
+}, {
+    readonly name: "branch-store-not-compiled";
+    readonly description: "The current branch's KB store must be compiled from the authored .kb/ sources; a missing or empty store is reported once, naming kibi sync, instead of every store-backed rule reading an empty KB";
+    readonly enforcementClass: "canonical";
+    readonly category: "integrity";
 }, {
     readonly name: "source-path-dangling";
     readonly description: "An authored entity's source field must name an existing workspace path (a #anchor suffix is ignored), an existing entity id, or an http(s) URL; a missing source is allowed";

package/dist/utils/rule-registry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqUlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4UlB,CAAC"}

package/dist/utils/rule-registry.generated.js

@@ -38,6 +38,12 @@ export const GENERATED_RULES = [
         enforcementClass: "canonical",
         category: "integrity",
     },
+    {
+        name: "branch-store-not-compiled",
+        description: "The current branch's KB store must be compiled from the authored .kb/ sources; a missing or empty store is reported once, naming kibi sync, instead of every store-backed rule reading an empty KB",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
     {
         name: "source-path-dangling",
         description: "An authored entity's source field must name an existing workspace path (a #anchor suffix is ignored), an existing entity id, or an http(s) URL; a missing source is allowed",

package/dist/utils/strict-modeling.d.ts

@@ -12,6 +12,12 @@ export interface SemanticClaim {
 export interface StrictModelInput {
     claim: SemanticClaim;
     statement: string;
+    /**
+     * The requirement the write set updates. When set it replaces the minted
+     * REQ-AUTO-<hash> id; fact ids, subject_key and the claim stay derived from
+     * the claim.
+     */
+    requirementId?: string;
 }
 type EntityProperties = Partial<Omit<BaseEntity, "created_at" | "updated_at"> & FactFields> & {
     id: string;
@@ -65,5 +71,11 @@ export declare function buildStrictWriteSet(input: StrictModelInput): StrictWrit
 export declare function modelRequirementClaims(inputs: ReadonlyArray<StrictModelInput>): StrictWriteSet[];
 export declare function normalizeSourceKey(value: string): string;
 export declare function normalizeTextRef(provenance: string | undefined, source: string): string;
+/**
+ * The file an authored fact lives in: `.kb/facts/<id>.md`. Kibi writes every
+ * fact there (the filename stem equals the id), so a plan that points at an
+ * existing fact names this path.
+ */
+export declare function factSourcePath(factId: string): string;
 export {};
 //# sourceMappingURL=strict-modeling.d.ts.map

package/dist/utils/strict-modeling.d.ts.map

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

package/dist/utils/strict-modeling.js

@@ -83,7 +83,9 @@ export function buildStableRequirementIds(claim) {
 export function buildStrictWriteSet(input) {
     const statement = normalizeStatement(input.statement);
     const confidence = normalizeConfidence(input.claim.confidence);
-    const ids = buildStableRequirementIds(input.claim);
+    const minted = buildStableRequirementIds(input.claim);
+    const requirementId = input.requirementId?.trim();
+    const ids = requirementId ? { ...minted, reqId: requirementId } : minted;
     const textRef = normalizeTextRef(input.claim.provenance, input.claim.source);
     const metadataTags = buildMetadataTags({
         confidence,
@@ -409,3 +411,12 @@ function normalizeEntityDirectory(directory) {
 function buildEntitySourcePath(directory, entityId) {
     return `${directory}/${entityId}.md`;
 }
+/**
+ * The file an authored fact lives in: `.kb/facts/<id>.md`. Kibi writes every
+ * fact there (the filename stem equals the id), so a plan that points at an
+ * existing fact names this path.
+ */
+// implements REQ-kibi-subject-vocabulary
+export function factSourcePath(factId) {
+    return buildEntitySourcePath(resolveEntitySourcePaths().facts, factId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,7 +235,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.18.0",
+    "kibi-core": "^0.18.1",
     "kibi-plugin-builtin": "^0.5.0",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",