kibi-cli 2.7.0 → 2.9.0

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgTlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuTlB,CAAC"}

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

@@ -164,6 +164,12 @@ export const GENERATED_RULES = [
         enforcementClass: "migration",
         category: "integrity",
     },
+    {
+        name: "related-requirement-unmodeled",
+        description: "A current requirement with unresolved (missing) propositions that relates_to a current requirement modeled with strict property or ground predicate facts; its claims are never compared by domain-contradictions until they are modeled against the same subject or predicates, or it supersedes that requirement",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
     {
         name: "proof-contract-symbols",
         description: "Detect unresolved required_proofs.symbol_id values, type-shape required proofs, and proof_bindings.source_file disagreement with the named symbol sourceFile",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.7.0",
+  "version": "2.9.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.16.0",
+    "kibi-core": "^0.17.0",
     "kibi-plugin-builtin": "^0.4.2",
     "kibi-plugin-sdk": "^0.4.1",
     "kibi-swipl": "^1.0.1",

package/src/public/operations/contracts.ts

@@ -393,8 +393,8 @@ const impactReviewAuthorship = objectData(
 );
 
 /**
- * kibi.job.v1 receipt returned by async-mode operations (kb_check with
- * `async: true`) instead of the synchronous payload. Agents poll
+ * kibi.job.v1 receipt returned by async-mode operations (kb_check and
+ * kb_apply_plan with `async: true`) instead of the synchronous payload. Agents poll
  * kb_job_status with the jobId. Declared as a union member of the operation
  * data contract so hosts validating tool output against the declared schema
  * accept the receipt without weakening the synchronous payload contract.
@@ -562,11 +562,20 @@ const BASE_DATA_SCHEMAS: Readonly<
         "provide_argument_bindings",
         "resolve_schema_reference",
         "record_ontology_gap",
+        "review_nonlogical",
+        "already_grounded",
       ],
     },
     recommendedPredicateSchema: { type: ["object", "null"] },
     applyPlan: recordArray,
     relationshipPlan: { type: ["object", "null"] },
+    relationshipTarget: {
+      type: ["string", "null"],
+      description:
+        "The planned predicate fact id (FACT-PRED-...) that a requires_predicate link must target. Candidate ids (SUGGEST-...) are never relationship targets.",
+    },
+    existingGrounding: recordArray,
+    replacementPlan: { type: ["object", "null"] },
     warnings: stringArray,
   }),
   kb_plan_bootstrap: objectData(
@@ -712,26 +721,33 @@ const BASE_DATA_SCHEMAS: Readonly<
     diagnostics: stringArray,
     capabilityPlugins: recordValue,
   }),
-  kb_apply_plan: objectData({
-    version: stringValue,
-    outcome: stringValue,
-    planHash: stringValue,
-    changedEntities: integerValue,
-    changedRelationships: integerValue,
-    changedPaths: stringArray,
-    finalSnapshots: recordValue,
-    validationSummary: recordValue,
-    recoveryJournalId: { type: ["string", "null"] },
-    deleted: integerValue,
-    sourcePaths: stringArray,
-    actionResults: recordArray,
-    notes: stringArray,
-    remainingPlan: recordValue,
-    closeout: recordValue,
-    status: stringValue,
-    effectFailures: recordArray,
-    nextActions: recordArray,
-  }),
+  kb_apply_plan: {
+    description:
+      "Synchronous apply result, or a kibi.job.v1 receipt when async:true detached the apply into a background job (poll kb_job_status with the jobId).",
+    anyOf: [
+      objectData({
+        version: stringValue,
+        outcome: stringValue,
+        planHash: stringValue,
+        changedEntities: integerValue,
+        changedRelationships: integerValue,
+        changedPaths: stringArray,
+        finalSnapshots: recordValue,
+        validationSummary: recordValue,
+        recoveryJournalId: { type: ["string", "null"] },
+        deleted: integerValue,
+        sourcePaths: stringArray,
+        actionResults: recordArray,
+        notes: stringArray,
+        remainingPlan: recordValue,
+        closeout: recordValue,
+        status: stringValue,
+        effectFailures: recordArray,
+        nextActions: recordArray,
+      }),
+      jobReceiptData,
+    ],
+  },
   kb_ingest_proof: objectData({
     artifactDigest: stringValue,
     environmentHash: stringValue,

package/src/public/operations/runtime-types.ts

@@ -185,6 +185,16 @@ export interface NetworkPort {
 
 export type Clock = () => Date;
 
+/** One progress report from a long-running operation (for example one applied plan action). */
+export type OperationProgress = Readonly<{
+  progress: number;
+  total?: number;
+  message?: string;
+}>;
+
+/** Host callback for progress reports; MCP forwards them as notifications/progress. */
+export type ProgressReporter = (progress: OperationProgress) => void;
+
 export type RuntimeOptions = {
   readonly workspaceRoot?: string;
   readonly signal?: AbortSignal;
@@ -195,6 +205,8 @@ export type RuntimeOptions = {
   readonly net?: NetworkPort;
   /** Optional injectable capability registry (or lazy factory). */
   readonly plugins?: OperationPlugins;
+  /** Optional progress sink for long-running operations. */
+  readonly onProgress?: ProgressReporter;
 };
 
 export type OperationContext = {
@@ -219,6 +231,8 @@ export type OperationContext = {
   readonly plugins?: OperationPlugins;
   /** Lazily materialize the workspace capability registry. */
   readonly ensurePlugins?: () => Promise<CapabilityRegistry>;
+  /** Progress sink a long-running operation reports to; absent when the host does not listen. */
+  readonly onProgress?: ProgressReporter;
 };
 export interface RuntimeOperationSpec<TInput = unknown, TResult = unknown> {
   readonly name: string;

package/src/public/operations/specs/check-rules.generated.ts

@@ -36,6 +36,7 @@ export const SELECTABLE_RULE_NAMES: readonly string[] = [
   "predicate-verifiability",
   "strict-readiness",
   "semantic-completeness",
+  "related-requirement-unmodeled",
   "proof-contract-symbols",
   "entity-id-style",
   "domain-redundancy",
@@ -58,4 +59,4 @@ export const SELECTABLE_RULE_NAMES: readonly string[] = [
 // 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, 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";
+  "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";

package/src/public/operations/specs/planning.ts

@@ -245,7 +245,13 @@ export const applyPlanSpec = {
         type: "string",
         pattern: "^[A-Za-z0-9._-]+$",
         description:
-          "Typed recovery journal identifier returned by a committed_with_repairs result or a PLAN_APPLY_RECOVERY_REQUIRED error. Recovery replays only the immutable journal and never the original plan request; a compile-plan journal (plan-apply-*) is completed or rolled back deterministically and reports which.",
+          "Typed recovery journal identifier returned by a committed_with_repairs result or a PLAN_APPLY_RECOVERY_REQUIRED error. Recovery replays only the immutable journal and never the original plan request; a compile-plan journal (plan-apply-*) is completed or rolled back deterministically and reports which. A bootstrap journal left `applying` by a process that died mid-action is resumed without edits: the interrupted action is re-applied and a source lock held by the dead process is reclaimed and recorded in the journal.",
+      },
+      async: {
+        type: "boolean",
+        default: false,
+        description:
+          "MCP only. When true, start the apply as a background job and return a kibi.job.v1 receipt immediately instead of holding the request open; poll kb_job_status with the returned jobId for the final result. Use for large bootstrap plans (hundreds of actions) that can outlast a client's request timeout. The MCP server registers kb_job_status only when KIBI_MCP_OPTIONAL_TOOLS includes it; otherwise async applies synchronously. A synchronous apply sends notifications/progress after each bootstrap action when the request carries a progressToken. The CLI ignores this field.",
       },
     },
   },

package/src/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.4.0
+version: 3.5.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -38,13 +38,13 @@ Seed branch-local Kibi knowledge from cited product intent, without creating a p
 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`. 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.
 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.
+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.
 9. **Read back** with `kb_query` and `kb_search` to confirm writes and citations.
 10. **Close out** with `kb_check`, then `kb_status`.
 11. **Deepen.** Bootstrap is complete; the KB is now half-way, holding cited `req` entries and review facts but no scenarios, tests or predicates. Load `kibi-usage` and continue in the normal Kibi workflow, one area at a time, telling the human what you author:
     - **Unplanned claims.** For every claim suppressed as `invalid_write` and every `sourceOnlySignals` entry ("Author requirement …"), restate the claim's statement and citation (`sourceId:reference`), model it with `kb_model` (`mode: "requirement"`, or `mode: "predicates"` for domain claims), and write the result with `kb_upsert` (`dryRun: true` first).
-    - **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, `expects`, and `assumes` links to the `property_value` facts whose values the scenario relies on, 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"},"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"` on each persisted requirement and apply a returned plan with `requires_predicate`, or record the `review:ontology-gap` observation it returns.
+    - **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, `expects`, the scenario prose in `document.body` (never in `properties`), and `assumes` links to the `property_value` facts whose values the scenario relies on, 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`. `already_grounded` means the bootstrap already grounded that claim; leave it unless the human wants the `replacementPlan` swap. 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`.
     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/src/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.4.0
+version: 2.5.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -263,10 +263,15 @@ prose. Bind them from the claim's own words and call again with the same
 ```
 
 When the retry returns `apply_requires_predicate`, write its `applyPlan` fact,
-then the `relationshipPlan` `requires_predicate` row. Record an ontology gap
+then the `relationshipPlan` `requires_predicate` row; its target is
+`relationshipTarget` (the planned `FACT-PRED-…` id), never a candidate's
+`SUGGEST-…` id. `already_grounded` means the requirement already grounds the
+claim (for example a bootstrap `requires_property` fact): a second grounding
+link would fail, so keep it or follow `replacementPlan`. Record an ontology gap
 only when no returned schema fits the claim, not because bindings were missing.
-A review note is an observation that quotes its claim without `claim_key`:
-`{"type":"fact","id":"FACT-review-<area>-<behavior>","properties":{"title":"Review: ...","status":"active","fact_kind":"observation","text_ref":"<sourceId>:<reference>","tags":["review:invalid-write"],"claim_text":"<the claim>"}}`.
+A review note is an observation that quotes its claim without `claim_key`, with
+its prose in `document.body`:
+`{"type":"fact","id":"FACT-review-<area>-<behavior>","properties":{"title":"Review: ...","status":"active","fact_kind":"observation","text_ref":"<sourceId>:<reference>","tags":["review:invalid-write"],"claim_text":"<the claim>"},"document":{"body":"<why it needs review, who raised it, the source>"}}`.
 
 To add `specified_by` (or another relationship) to an existing requirement,
 upsert it with its stored `title`, a `status` and the relationship only; Kibi