kibi-runtime 2.13.1 → 2.13.2

package/dist/engine-daemon.js

@@ -102,7 +102,7 @@ function manifestVersion(manifestPath, expectedName) {
 }
 function cliVersion() {
   if (true)
-    return "2.16.0";
+    return "2.17.0";
   return manifestVersion(path.join(moduleDirectory, "..", "package.json"), "kibi-cli") ?? "unknown";
 }
 function coreVersion() {

package/dist/index.js

@@ -6757,7 +6757,7 @@ function manifestVersion(manifestPath, expectedName) {
 }
 function cliVersion() {
   if (true)
-    return "2.16.0";
+    return "2.17.0";
   return manifestVersion(path2.join(moduleDirectory, "..", "package.json"), "kibi-cli") ?? "unknown";
 }
 function coreVersion() {
@@ -13780,7 +13780,7 @@ async function executeStatus(_input, context) {
     const enrichedPayload = {
       ...payload,
       ...compilerReason ? { syncState: "stale", dirty: true } : {},
-      ...storeUncompiled && store.state === "healthy" ? { syncState: "stale", dirty: true } : {},
+      ...storeUncompiled ? { syncState: "stale", dirty: true } : {},
       branchAttachment: attachment,
       branchStore: store,
       ...engineStatus ? { engineStatus } : {},
@@ -14087,10 +14087,21 @@ function sourceOf(payload) {
 function normalizeKey(value) {
   return value.trim().toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
-function singularize(value) {
-  if (["status", "results"].includes(value))
+function singularizeToken(value, keep = []) {
+  if (value.length <= 3 || keep.includes(value))
+    return value;
+  if (value.endsWith("ies") && value.length > 4) {
+    return `${value.slice(0, -3)}y`;
+  }
+  if (ES_PLURAL_SUFFIXES.some((suffix) => value.endsWith(suffix))) {
+    return value.slice(0, -2);
+  }
+  if (!value.endsWith("s") || /(?:ss|us|is)$/.test(value))
     return value;
-  return value.endsWith("s") && value.length > 3 ? value.slice(0, -1) : value;
+  return value.slice(0, -1);
+}
+function singularize(value) {
+  return singularizeToken(value, ["status", "results"]);
 }
 function normalizeSubjectKey(value) {
   return normalizeKey(value).split("_").map(singularize).join(".");
@@ -14220,9 +14231,10 @@ function predicateSuggestion(payload, evidence, name, args, rationale, polarity
     } : null
   };
 }
-var SEMANTIC_INVENTORY_VERSION = "kibi.semantic-inventory.v1";
+var SEMANTIC_INVENTORY_VERSION = "kibi.semantic-inventory.v1", ES_PLURAL_SUFFIXES;
 var init_shared = __esm(() => {
   init_clauses();
+  ES_PLURAL_SUFFIXES = ["ches", "shes", "sses", "xes"];
 });
 
 // ../cli/dist/operations/semantic-advisor/ingestion-boundary.js
@@ -43374,13 +43386,34 @@ function coverageForRequirement(result, manifestResults, entities) {
     scenarioTests
   };
 }
+function supersededRequirementIds(manifestResults) {
+  return new Set(manifestResults.flatMap((result) => result.entity.type === "req" ? result.relationships.flatMap((relationship) => relationship.type === "supersedes" ? [relationship.to] : []) : []));
+}
+function isReviewableRequirement(requirement, superseded) {
+  if (superseded.has(requirement.id))
+    return false;
+  const status = requirement.status.trim().toLowerCase();
+  if (REVIEWED_REQUIREMENT_STATUSES.has(status))
+    return true;
+  return status === "closed" && (requirement.tags ?? []).includes("implemented");
+}
 function createCoverageDepthQualityDiagnostics(manifestResults, proofByRequirement = new Map) {
   const entities = entitiesById(manifestResults);
-  return manifestResults.filter((result) => result.entity.type === "req").flatMap((result) => {
+  const superseded = supersededRequirementIds(manifestResults);
+  return manifestResults.filter((result) => result.entity.type === "req" && isReviewableRequirement(result.entity, superseded)).flatMap((result) => {
     const diagnostic = createDiagnostic(coverageForRequirement(result, manifestResults, entities), proofByRequirement.get(result.entity.id));
     return diagnostic === undefined ? [] : [diagnostic];
   }).toSorted((left, right) => (left.entityId ?? "").localeCompare(right.entityId ?? ""));
 }
+var REVIEWED_REQUIREMENT_STATUSES;
+var init_coverage_depth_quality = __esm(() => {
+  REVIEWED_REQUIREMENT_STATUSES = new Set([
+    "open",
+    "in_progress",
+    "active",
+    "approved"
+  ]);
+});
 
 // ../cli/dist/public/impact/requirement-quality.js
 function isRequirement2(result) {
@@ -44053,6 +44086,7 @@ var init_full_kb_quality = __esm(() => {
   init_proof_receipt();
   init_relationship();
   init_telemetry_acceptance();
+  init_coverage_depth_quality();
   init_requirement_quality();
   init_symbol_quality();
   RELATIONSHIP_TYPES = relationship_default.properties.type.enum;
@@ -55597,9 +55631,7 @@ function normalizePredicateToken(value) {
   return value.trim().replace(/\b(?:a|an|the)\b\s*/gi, "").replace(/['’]/g, "").replace(/\s+/g, "_").replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
 }
 function singularize2(value) {
-  if (["changes", "status", "results"].includes(value))
-    return value;
-  return value.endsWith("s") && value.length > 3 ? value.slice(0, -1) : value;
+  return singularizeToken(value, ["changes", "status", "results"]);
 }
 function normalizeSubjectKey3(value) {
   return slug2(value).split("_").map(singularize2).join(".");
@@ -55671,7 +55703,9 @@ function inferEvent(text) {
   return eventName ?? "domain_event";
 }
 var DEFAULT_MIN_SCORE = 0.35;
-var init_predicate_utils = () => {};
+var init_predicate_utils = __esm(() => {
+  init_shared();
+});
 
 // ../cli/dist/operations/modeling/predicate-ranker.js
 function tokens3(value) {
@@ -56016,7 +56050,10 @@ var init_predicate_applicability = __esm(() => {
     permission_rule: {
       allOf: [
         [/only|may|can|allowed|denied|forbidden|must\s+not|cannot/i],
-        [/delete|export|access|read|write|update|remove|manage|permission/i]
+        [
+          /delete|export|access|read|write|update|remove|manage|permission/i,
+          /\b(?:may|can|cannot|can't|must\s+(?:not|never)|never|(?:is|are)\s+(?:not\s+)?(?:allowed|permitted|forbidden)\s+to)\s+(?:only\s+)?(?:publish|unpublish|approve|assign|view|see|edit|modify|create|submit|share|invite|upload|download|comment|post|complete|archive|restore|grant|revoke|purchase|cancel|execute|invoke|configure|moderate|ban|join|book|reserve|transfer|close|reopen|merge)\b/i
+        ]
       ]
     },
     resource_constraint: {
@@ -74965,6 +75002,17 @@ var init_cli_operation_metadata = __esm(() => {
 // ../cli/dist/cli-validate.js
 var init_cli_validate = () => {};
 
+// ../cli/dist/operations/planning/migration-refusal.js
+var MigrationActionRefusedError, MIGRATION_PLAN_REFUSED = "MIGRATION_PLAN_REFUSED";
+var init_migration_refusal = __esm(() => {
+  MigrationActionRefusedError = class MigrationActionRefusedError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "MigrationActionRefusedError";
+    }
+  };
+});
+
 // ../cli/dist/public/operations/result-envelope.js
 function record4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -75056,23 +75104,33 @@ function extraFailedEffects(declared, data) {
 function resultVersion(spec) {
   return spec.resultVersion ?? `kibi.${spec.name}.v1`;
 }
+function refusalDetail(row) {
+  const results = Array.isArray(row.actionResults) ? row.actionResults : [];
+  const failure = results.find((entry) => record4(entry) && entry.outcome === "failed");
+  return record4(failure) && typeof failure.detail === "string" ? failure.detail : "";
+}
 function toKibiResult(spec, data, options2 = {}) {
   const row = record4(data) ? data : undefined;
+  const migrationRefused = row?.version === "kibi.migration-apply-result.v1" && row.outcome === "refused";
   let status = options2.status;
   if (!status) {
     status = "success";
     if (row?.status === "committed_with_repairs")
       status = "committed_with_repairs";
-    if (row?.status === "rejected")
+    if (row?.status === "rejected" || migrationRefused)
       status = "error";
   }
   const terminalError = row?.status === "rejected" ? {
     code: "BOOTSTRAP_PLAN_REJECTED",
     message: "Bootstrap stopped at a deterministic failure. Inspect actionResults for committed actions and re-plan from the current state.",
     retryable: false
+  } : migrationRefused ? {
+    code: MIGRATION_PLAN_REFUSED,
+    message: `Migration plan refused; nothing was changed. ${refusalDetail(row)}`.trim(),
+    retryable: false
   } : undefined;
   const resultError = options2.error ?? terminalError;
-  const outcome = effectOutcome(status, options2);
+  const outcome = effectOutcome(status, migrationRefused && options2.attempted === undefined ? { ...options2, attempted: false } : options2);
   return {
     kibiProtocol: KIBI_PROTOCOL_VERSION,
     operation: spec.name,
@@ -75121,6 +75179,9 @@ function appendPayloadCountField(fields, countKey, noun, payload) {
   fields.result_summary = count === null ? `${noun} count unavailable` : `${count} ${noun}`;
 }
 var KIBI_PROTOCOL_VERSION = 1;
+var init_result_envelope = __esm(() => {
+  init_migration_refusal();
+});
 
 // ../cli/dist/cli-protocol.js
 var import__2020, outputValidator;
@@ -75130,6 +75191,7 @@ var init_cli_protocol = __esm(() => {
   init_cli_operation_metadata();
   init_cli_validate();
   init_engine_limits();
+  init_result_envelope();
   init_detached_snapshot();
   import__2020 = __toESM(require__2020(), 1);
   outputValidator = new import__2020.default({ strict: false, allErrors: true });
@@ -75138,6 +75200,7 @@ var init_cli_protocol = __esm(() => {
 // ../cli/dist/public/diagnostic-usage.js
 var RECEIPT_GAP_CODES;
 var init_diagnostic_usage = __esm(() => {
+  init_result_envelope();
   RECEIPT_GAP_CODES = new Set([
     "missing_proof_receipt",
     "stale_proof_receipt",
@@ -76010,32 +76073,32 @@ function applyProofIntegrationAction(action, root) {
   const evidence = action.evidence;
   const integration = evidence.integration;
   if (evidence.path !== PROOF_INTEGRATIONS_PATH || evidence.mode !== "create" && evidence.mode !== "update" || !isRecord22(integration) || typeof integration.id !== "string")
-    throw new Error(`Proof integration action '${action.id}' is malformed; rerun kibi proof inspect for a new plan.`);
+    throw new MigrationActionRefusedError(`Proof integration action '${action.id}' is malformed; rerun kibi proof inspect for a new plan.`);
   const planned = isRecord22(evidence.sourceHashes) ? evidence.sourceHashes : {};
   const live = sourceHashes(root);
   const changed = [
     ...new Set([...Object.keys(planned), ...Object.keys(live)])
   ].filter((file) => planned[file] !== live[file]);
   if (changed.length > 0)
-    throw new Error(`Proof integration plan refused: ${changed.join(", ")} changed since planning; rerun kibi proof inspect and review the new plan.`);
+    throw new MigrationActionRefusedError(`Proof integration plan refused: ${changed.join(", ")} changed since planning; rerun kibi proof inspect and review the new plan.`);
   const filePath = integrationsPath(root);
   let integrations;
   if (evidence.mode === "create") {
     if (existsSync42(filePath))
-      throw new Error(`Proof integration plan refused: ${PROOF_INTEGRATIONS_PATH} already exists and this plan only creates it. Run kibi proof inspect --update <integration id> for a plan that adds or replaces one named integration.`);
+      throw new MigrationActionRefusedError(`Proof integration plan refused: ${PROOF_INTEGRATIONS_PATH} already exists and this plan only creates it. Run kibi proof inspect --update <integration id> for a plan that adds or replaces one named integration.`);
     integrations = [integration];
   } else {
     if (fileHash3(filePath) !== evidence.previousFileHash)
-      throw new Error(`Proof integration plan refused: ${PROOF_INTEGRATIONS_PATH} changed since planning; rerun kibi proof inspect --update ${integration.id}.`);
+      throw new MigrationActionRefusedError(`Proof integration plan refused: ${PROOF_INTEGRATIONS_PATH} changed since planning; rerun kibi proof inspect --update ${integration.id}.`);
     const current = readIntegrationsFile(root);
     if (current === null)
-      throw new Error(`Proof integration plan refused: ${PROOF_INTEGRATIONS_PATH} is not a valid ${PROOF_INTEGRATION_VERSION} file.`);
+      throw new MigrationActionRefusedError(`Proof integration plan refused: ${PROOF_INTEGRATIONS_PATH} is not a valid ${PROOF_INTEGRATION_VERSION} file.`);
     integrations = current.integrations.some((entry) => entry.id === integration.id) ? current.integrations.map((entry) => entry.id === integration.id ? integration : entry) : [...current.integrations, integration];
   }
   const file = { version: PROOF_INTEGRATION_VERSION, integrations };
   const errors = proofIntegrationErrors(file);
   if (errors.length > 0)
-    throw new Error(`Proof integration plan refused: the result would be invalid (${errors.join("; ")}).`);
+    throw new MigrationActionRefusedError(`Proof integration plan refused: the result would be invalid (${errors.join("; ")}).`);
   mkdirSync17(path80.dirname(filePath), { recursive: true });
   const temporary = `${filePath}.${process.pid}.tmp`;
   writeFileSync20(temporary, `${JSON.stringify(file, null, 2)}
@@ -76044,6 +76107,7 @@ function applyProofIntegrationAction(action, root) {
 }
 var PROOF_INTEGRATION_CONFIGURE = "proof_integration_configure", PROPOSAL_SOURCES;
 var init_integration_plan = __esm(() => {
+  init_migration_refusal();
   init_migration_plan();
   init_proof_protocol();
   init_integrations();
@@ -78531,6 +78595,8 @@ async function applyMigrationPlan(args, context, onCommitted = () => {
   }
   const results = [];
   let failed = false;
+  let refusals = 0;
+  let failures = 0;
   for (const action of actions) {
     if (failed) {
       results.push({
@@ -78550,6 +78616,9 @@ async function applyMigrationPlan(args, context, onCommitted = () => {
       });
     } catch (error) {
       failed = true;
+      failures += 1;
+      if (error instanceof MigrationActionRefusedError)
+        refusals += 1;
       results.push({
         actionId: action.id,
         outcome: "failed",
@@ -78596,7 +78665,7 @@ async function applyMigrationPlan(args, context, onCommitted = () => {
       });
     }
   }
-  const outcome = failed ? results.some((result) => result.outcome === "applied") ? "partially_applied" : "reconciliation_required" : "applied";
+  const outcome = failed ? results.some((result) => result.outcome === "applied") ? "partially_applied" : failures > 0 && refusals === failures ? "refused" : "reconciliation_required" : "applied";
   const kbState = finalStatus.branchAttachment?.migrationRequired ? "legacy_compat" : finalStatus.syncState === "stale" ? "stale" : finalStatus.dirty ? "dirty" : finalStatus.syncState === "fresh" ? "clean_fresh" : "not_evaluated";
   const snapshotState = finalStatus.proofSnapshotAvailable === false ? "unavailable" : finalStatus.proofSnapshotDirty === true ? "dirty" : finalStatus.proofSnapshotDirty === false ? "fresh" : "not_evaluated";
   const proven = coverageSummary?.proofProven;
@@ -78617,7 +78686,7 @@ async function applyMigrationPlan(args, context, onCommitted = () => {
     ],
     ...remainingPlan !== undefined ? { remainingPlan } : {},
     closeout: {
-      taskOutcome: outcome === "applied" ? "complete" : outcome === "reconciliation_required" ? "blocked" : "interim",
+      taskOutcome: outcome === "applied" ? "complete" : outcome === "reconciliation_required" || outcome === "refused" ? "blocked" : "interim",
       kbState,
       snapshotState,
       proofState,
@@ -78628,7 +78697,7 @@ async function applyMigrationPlan(args, context, onCommitted = () => {
     content: [
       {
         type: "text",
-        text: `${outcome === "applied" ? "Applied" : "Stopped after"} migration plan ${args.plan.planHash.slice(0, 12)}.`
+        text: outcome === "applied" ? `Applied migration plan ${args.plan.planHash.slice(0, 12)}.` : outcome === "refused" ? `Refused migration plan ${args.plan.planHash.slice(0, 12)}; nothing was changed.` : `Stopped after migration plan ${args.plan.planHash.slice(0, 12)}.`
       }
     ],
     structuredContent: payload
@@ -78703,16 +78772,16 @@ async function applyMigrationAction(action, context) {
         await applySchema6MigrationAction(action, context);
         return;
       }
-      throw new Error(`Migration action '${action.code}' has no automatic executor.`);
+      throw new MigrationActionRefusedError(`Migration action '${action.code}' has no automatic executor.`);
   }
 }
 async function applyPredicateSchemaAlignment(action, context) {
   const invocation = action.invocation;
   if (invocation.kind !== "operation" || invocation.name !== "kb_upsert")
-    throw new Error("Predicate schema alignment requires its planned kb_upsert invocation.");
+    throw new MigrationActionRefusedError("Predicate schema alignment requires its planned kb_upsert invocation.");
   const input = asUpsert(invocation.input);
   if (input.type !== "fact")
-    throw new Error("Predicate schema alignment only rewrites fact entities.");
+    throw new MigrationActionRefusedError("Predicate schema alignment only rewrites fact entities.");
   const prolog = context.prolog ?? await context.ensureProlog?.();
   if (!prolog)
     throw new Error("Predicate schema alignment requires a Prolog runtime.");
@@ -78724,7 +78793,7 @@ async function applyPredicateSchemaAlignment(action, context) {
   const rewrites = Array.isArray(evidence.rewrites) ? evidence.rewrites : [];
   const unchanged = current !== undefined && current.fact_kind === "predicate" && currentNamespace === evidence.namespace && rewrites.every((rewrite) => isRecord24(rewrite) && typeof rewrite.index === "number" && currentArgs[rewrite.index] === rewrite.from);
   if (!unchanged)
-    throw new Error(`Predicate fact ${input.id} changed since planning; rerun kibi check and approve the new plan.`);
+    throw new MigrationActionRefusedError(`Predicate fact ${input.id} changed since planning; rerun kibi check and approve the new plan.`);
   await executeUpsert(input, operationContext);
 }
 var PLAN_APPLY_RESULT_VERSION = "kibi.plan-apply-result.v1", ENTITY_TYPES4;
@@ -78752,6 +78821,7 @@ var init_apply_plan = __esm(() => {
   init_upsert();
   init_workspace_mutation_lock();
   init_compile_intent();
+  init_migration_refusal();
   ENTITY_TYPES4 = new Set([
     "req",
     "scenario",
@@ -80347,6 +80417,7 @@ init_branch_store_locator();
 init_detached_snapshot();
 
 // src/index.ts
+init_result_envelope();
 init_engine();
 
 // ../cli/dist/public/prolog/index.js

package/dist/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.12.0
+version: 2.13.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -148,7 +148,13 @@ error `BOOTSTRAP_PLAN_REJECTED` can follow earlier committed actions: inspect
 `data.actionResults` and `data.applied`, then re-plan from the current state.
 Its journal is terminal; never recover or replay it. `BOOTSTRAP_PLAN_INVALID`
 fails preflight before bootstrap writes or a new journal; obtain a corrected
-plan. If the status is
+plan. A migration plan whose actions were refused before changing anything
+returns `status: error`, `MIGRATION_PLAN_REFUSED` and `data.outcome:
+refused`: nothing changed, so read the action `detail` and get a new plan.
+`data.outcome: reconciliation_required` (status success) means an action
+failed mid-way: inspect its effect before retrying. `kb_delete` of an
+authored entity returns status success with `deleted: 0`; its `errors` say
+why nothing was deleted. If the status is
 `committed_with_repairs`, the mutation already committed: inspect failed effects,
 execute each required repair action in order, and never retry the original
 operation. Record effect failures, followed actions, and unsafe retries in

package/dist/skills/kibi-usage/resources/fact-lanes.md

@@ -61,16 +61,16 @@ A schema can close an argument with `argument_constants` (allowed values keyed b
 
 ### Deny predicate
 
-Claim: “Suspended users must not publish articles.” When `permission_rule` fits, preserve its positive schema name and encode prohibition as polarity:
+Claim: “Suspended users must not publish articles.” When `permission_rule` fits, preserve its positive schema name and encode prohibition as polarity. `kb_model` (`mode: "predicates"`) plans this fact for the claim; the built-in schema's fourth argument, `decision`, repeats the polarity:
 
 ```yaml
 id: FACT-SUSPENDED-PUBLISH-DENIED
 status: active
 fact_kind: predicate
 predicate_name: permission_rule
-predicate_args: [suspended_user, publish, article]
+predicate_args: [suspended_user, publish, articles, deny]
 polarity: deny
-canonical_key: permission_rule(suspended_user,publish,article)
+canonical_key: permission_rule(suspended_user,publish,articles,deny)
 claim_key: <advisor-issued key for this exact clause>
 claim_text: Suspended users must not publish articles.
 relationship: { type: requires_predicate, from: REQ-SUSPENDED-PUBLISH-DENIED, to: FACT-SUSPENDED-PUBLISH-DENIED }

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

@@ -51,6 +51,15 @@ proof_bindings:                 # optional provenance metadata
 
 Provenance lives in `proof_bindings`; the contract stays semantic.
 
+- Every `required_proofs[].symbol_id` must name an existing `symbol` entity,
+  or `kb_check` reports `proof-contract-symbols`. Create the symbols first
+  (`kb_upsert`, narrow method-level granularity, never a `type-shape`
+  symbol): a production symbol `implements` the requirement and is
+  `covered_by` the test; an executable test symbol is `executable_for` it.
+- `proof_bindings[].source_file`, when set, must equal the named symbol's
+  `sourceFile`: for a production symbol that is the production file, not the
+  spec file that exercises it. Omit it when unsure.
+
 ## Integration configuration
 
 `.kb/proof/integrations.json` (`kibi.proof-integration.v1`) is tracked,
@@ -62,12 +71,21 @@ returns `integrationPlan`, a hash-bound `kibi.migration-plan.v2`, plus 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.
+refused (`status: error`, `MIGRATION_PLAN_REFUSED`, `data.outcome: refused`;
+nothing is written); `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
-  single process invocation counts as the known first attempt.
+  single process invocation counts as the known first attempt. The run is
+  judged as a whole: any failing test in it fails every obligation of every
+  test that names the integration, so a suite with unrelated failures proves
+  nothing. Narrow the command to the proof-bearing tests with
+  `kibi proof inspect --update <id> --command "<command>" --json` (without
+  `--command` the proposal is the `package.json` `test` script or the
+  detected runner again), or make the run attributable per test: have the
+  command write a `kibi.proof-test-report.v1` to the path in
+  `KIBI_PROOF_TEST_REPORT` so each test is judged by its own steps.
 - `producer: playwright` (or custom) — the child emits `kibi.proof-run.v1`
   itself (bundled reporter: `kibi-cli/playwright-reporter`).
 - `producer: junit` / `tap` — Kibi converts the native report at `artifact`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-runtime",
-  "version": "2.13.1",
+  "version": "2.13.2",
   "description": "Narrow first-party runtime contracts and adapters for Kibi operations.",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "gray-matter": "^4.0.3",
-    "kibi-core": "^0.18.1",
+    "kibi-core": "^0.18.2",
     "kibi-plugin-builtin": "^0.5.0",
     "kibi-swipl": "^1.0.1"
   },