kibi-cli 2.18.0 → 2.20.0

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

@@ -707,6 +707,50 @@ export declare const upsertSpec: {
                 readonly default: false;
                 readonly description: "Validate the payload and return schema/modeling errors, a normalized preview and the semantic advisor receipt without writing the KB or workspace. Use it as the preflight before the real write.";
             };
+            readonly plannedFacts: {
+                readonly type: "array";
+                readonly description: "dryRun only. Fact upsert payloads (type, id, properties, optional relationships) that will be written before this payload, typically the applyPlan entries kb_model returned. They are validated in order and staged with the payload, so a requires_predicate or requires_property target that does not exist yet resolves, its claim_key is read from the plan, and the contradiction preview runs against the KB as it would be after the whole batch (result: stagedFacts, whatIf). A conflict the batch would introduce, such as an allow and a deny permission_rule on the same key, is refused as the commit would refuse it. Rejected without dryRun: write the facts first.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type", "id", "properties"];
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly const: "fact";
+                        };
+                        readonly id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly properties: {
+                            readonly type: "object";
+                        };
+                        readonly relationships: {
+                            readonly type: "array";
+                            readonly description: "Optional relationship rows to create in the same call. For requirement encoding, prefer `constrains` + `requires_property` for strict property facts or `requires_predicate` for ontology predicate facts. Side effect: asserts edges in KB.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly required: readonly ["type", "from", "to"];
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "restates", "assumes", "exempts", "relates_to"];
+                                        readonly description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).";
+                                    };
+                                    readonly from: {
+                                        readonly type: "string";
+                                        readonly description: "Source entity ID (must exist). Example: 'SYM-login-handler'.";
+                                    };
+                                    readonly to: {
+                                        readonly type: "string";
+                                        readonly description: "Target entity ID (must exist). Example: 'REQ-cli-gc'.";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
             readonly document: {
                 readonly type: "object";
                 readonly additionalProperties: false;

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

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}

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

@@ -24,6 +24,20 @@ export const upsertSpec = {
                 default: false,
                 description: "Validate the payload and return schema/modeling errors, a normalized preview and the semantic advisor receipt without writing the KB or workspace. Use it as the preflight before the real write.",
             },
+            plannedFacts: {
+                type: "array",
+                description: "dryRun only. Fact upsert payloads (type, id, properties, optional relationships) that will be written before this payload, typically the applyPlan entries kb_model returned. They are validated in order and staged with the payload, so a requires_predicate or requires_property target that does not exist yet resolves, its claim_key is read from the plan, and the contradiction preview runs against the KB as it would be after the whole batch (result: stagedFacts, whatIf). A conflict the batch would introduce, such as an allow and a deny permission_rule on the same key, is refused as the commit would refuse it. Rejected without dryRun: write the facts first.",
+                items: {
+                    type: "object",
+                    required: ["type", "id", "properties"],
+                    properties: {
+                        type: { type: "string", const: "fact" },
+                        id: { type: "string", minLength: 1 },
+                        properties: { type: "object" },
+                        relationships: RELATIONSHIPS_SCHEMA,
+                    },
+                },
+            },
             document: {
                 type: "object",
                 additionalProperties: false,

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.14.0
+version: 2.15.2
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -82,6 +82,41 @@ different workspace than the one you asked for; its `detail.reason` says why.
 Use the CLI from your working directory instead: `npx --no-install kibi ...`
 runs where you are and needs no `workspaceRoot`.
 
+## Reading a hook snippet
+
+On hosts where Kibi hooks are installed, a short block
+arrives before you read or edit a file whose symbols are linked to
+requirements. It is projected from `.kb/symbols.yaml`, not from the store, so
+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.
+- `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.
+- `Decision: ADR-…` (edit only): the decision behind the lead requirement.
+- `Covered by: TEST-…` and `Test code for: …`: the tests that prove the
+  file's symbols; run or update them with the edit.
+- `The edit is inside <symbol>, which implements REQ-…`: the symbol the edit
+  lands in.
+- `Next layer: …`: the exact `kb_query` and `kb_search(... sourceLocations)`
+  calls that return the full detail.
+- The `kb_check({sourceFiles:[…], includeImpactDiagnostics:true,
+  includeWorkingTreeDiff:true})` line (edit only): run it after the edit. The
+  Stop hook reminds you once per session of files edited without it.
+
+A file already shown this session gets only the one-line `Kibi: this edit to
+<path> is inside <symbol>` update; the facts and tests from its first snippet
+still apply. `Kibi: no symbol in <path> is linked to a requirement yet` means
+the file is unowned: find the governing requirement with `kb_search` and
+`sourceLocations`, then link a symbol to it with `implements` through
+`kb_upsert`. Without a readable manifest (`Kibi: the hook could not read
+.kb/symbols.yaml`) snippets are off for this session; `kb_query({sourceFile})`
+still answers and `kibi sync` regenerates the manifest. The search tip and the
+`.kb/` note appear once per session and need no action.
+
 ## Safe workflow
 
 1. Always discover before you mutate: start with `kb_search`, then exact-filter with `kb_query`. Use
@@ -409,6 +444,14 @@ Prolog `symbol-coverage` also requires the test to `validates` the requirement
 enough. Do not rely on legacy `// implements REQ-<area>-<behavior>` comments as the
 traceability record.
 
+Set the symbol's `title` to the behavioral member the extractor can locate in
+`sourceFile`: `ClassName.methodName`, an exported function, or a class, not a
+file or module name. A traceability link (`implements`, `covered_by`, …) from
+a symbol whose `title` names no such member is refused by the granularity gate
+when the file already has granular behavioral symbols, unless the symbol sets
+`granularity_reason` to `config-artifact`, `module-level-behavior`,
+`extractor-miss`, `legacy-link` or `test-suite`.
+
 ## Complete Logical Coverage
 
 Decompose all atomic normative clauses into `claim_key`/`claim_text` entries in

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

@@ -68,14 +68,16 @@ id: FACT-SUSPENDED-PUBLISH-DENIED
 status: active
 fact_kind: predicate
 predicate_name: permission_rule
-predicate_args: [suspended_user, publish, articles, deny]
+predicate_args: [suspended_user, publish, article, deny]
 polarity: deny
-canonical_key: permission_rule(suspended_user,publish,articles,deny)
+canonical_key: permission_rule(suspended_user,publish,article,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 }
 ```
 
+Inferred bindings drop the article and singularise the resource (`articles` becomes `article`, `any analysis request` and `analysis requests` both become `analysis_request`), so an allow and a deny on the same actor, action and resource share one key. Grants read the same as `allowed`: `may`, `can`, `is allowed to`, `are permitted to`, `must be able to`, `are able to`, `have permission to` and `are entitled to` all select `permission_rule` with `polarity: assert`.
+
 If another current requirement links an `assert` fact with the same predicate namespace, name, and ordered arguments, `domain-contradictions` reports the pair. More complex semantic conflicts require a shared canonical schema and arguments; do not assume Kibi can prove arbitrary equivalence between differently shaped predicates.
 
 The full logical representation of a requirement is the conjunction of all of its linked ground property and predicate terms. Conditions, exceptions, permissions, and ordering constraints remain explicit arguments of their declared schemas. Contradiction detection therefore depends on equivalent prose reusing the same predicate name, argument roles, ordered canonical values, and opposing polarity rather than inventing synonymous terms.

package/dist/runtime/cli-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/cli-runtime.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAKV,gBAAgB,EAEhB,cAAc,EACf,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,6BAA6B,CAAC;AAOrC,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAOR;AA2GD,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,cAAmB,GAC3B,gBAAgB,CA4IlB"}
+{"version":3,"file":"cli-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/cli-runtime.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAKV,gBAAgB,EAEhB,cAAc,EACf,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,6BAA6B,CAAC;AAOrC,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAOR;AA2GD,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,cAAmB,GAC3B,gBAAgB,CAgJlB"}

package/dist/runtime/cli-runtime.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { retryAttachAfterBreakingStaleLock } from "../prolog/store-lock.js";
+import { noteDeadHolderBeforeAttach, retryAttachAfterBreakingStaleLock, } from "../prolog/store-lock.js";
 import { EngineClient } from "../engine.js";
 import { CapabilityRegistryCache, ensureCapabilityRegistry, } from "../plugins/registry.js";
 import { nodeFilesystem, nodeGit, nodeNetwork, } from "../public/operations/node-ports.js";
@@ -186,8 +186,13 @@ export function createCliRuntime(options = {}) {
                 await prolog.start?.();
                 const kbPath = attachment.storePath;
                 if (!usesEngine) {
+                    // implements REQ-core-journaled-engine-persistence
+                    // A killed holder never makes kb_attach fail, so note it first.
+                    const recordTakeover = noteDeadHolderBeforeAttach(kbPath);
                     let attached = await prolog.query(`kb_attach('${quoteProlog(kbPath)}')`);
-                    if (!attached.success) {
+                    if (attached.success)
+                        recordTakeover();
+                    else {
                         attached = await retryAttachAfterBreakingStaleLock(prolog, kbPath, attached);
                     }
                     if (!attached.success) {

package/dist/search-answer.d.ts

@@ -66,12 +66,21 @@ export type SearchAnswerVerdict = Readonly<{
 export type SearchAnswerException = SearchAnswerEntity & Readonly<{
     approvedBy?: string;
 }>;
+/**
+ * A linked fact says what it states in its typed form, so an agent can read
+ * `has_role(alice, admin)` or `user.role_assignment max_roles lte 2` without
+ * opening the entity, and `ask` is the exact kb_query that answers precise
+ * questions about the same predicate or subject.
+ */
+export type SearchAnswerFact = SearchAnswerEntity & Readonly<{
+    factKind?: string;
+    claim?: string;
+    ask?: string;
+}>;
 export type SearchAnswerRequirement = SearchAnswerEntity & Readonly<{
     score: number;
     via: string;
-    facts: readonly (SearchAnswerEntity & {
-        factKind?: string;
-    })[];
+    facts: readonly SearchAnswerFact[];
     scenarios: readonly SearchAnswerEntity[];
     tests: readonly SearchAnswerTest[];
     adrs: readonly SearchAnswerEntity[];
@@ -85,6 +94,17 @@ export type SearchAnswerScope = Readonly<{
     snapshotId: string;
     syncedAt: string | null;
 }>;
+/**
+ * A matched fact, scenario, test or symbol that no requirement owns, with
+ * its 1-based `rank` in the search results. When the top-ranked match is
+ * here, the governing list was reached through lower-ranked matches, and
+ * the answer says so instead of presenting those requirements as the top
+ * match's.
+ */
+export type SearchAnswerUngoverned = SearchAnswerFact & Readonly<{
+    type: string;
+    rank: number;
+}>;
 export type SearchAnswer = Readonly<{
     version: "kibi.search-answer.v1";
     governing: readonly SearchAnswerRequirement[];
@@ -93,6 +113,7 @@ export type SearchAnswer = Readonly<{
         supersededBy?: string;
     })[];
     observations: readonly SearchAnswerEntity[];
+    ungoverned: readonly SearchAnswerUngoverned[];
     scope: SearchAnswerScope;
     truncated: boolean;
     note: string;
@@ -110,6 +131,7 @@ export declare const SEARCH_ANSWER_LIMITS: {
     readonly rationale: 3;
     readonly notGoverning: 5;
     readonly observations: 3;
+    readonly ungoverned: 5;
     /** Entity rows loaded per answer, the matched seeds included. */
     readonly entityLoads: 70;
     readonly maxBytes: 16384;

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":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAW5D,OAAO,KAAK,EACV,UAAU,EAEX,MAAM,sCAAsC,CAAC;AAI9C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAEH;;;GAGG;AAEH,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE9E,sEAAsE;AAEtE,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,GACpD,QAAQ,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElD,0EAA0E;AAE1E,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,KAAK,EAAE,uBAAuB,GAAG,sBAAsB,CAAC;IACxD,MAAM,EAAE,eAAe,GAAG,YAAY,CAAC;IACvC,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH;;;;;GAKG;AAEH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,IAAI,EACA,0BAA0B,GAC1B,qBAAqB,GACrB,wBAAwB,GACxB,qBAAqB,GACrB,qBAAqB,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAGH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC;;;;OAIG;IACH,MAAM,EAAE,eAAe,GAAG,YAAY,GAAG,SAAS,GAAG,MAAM,CAAC;IAC5D,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC3C,CAAC,CAAC;AAEH,sDAAsD;AAEtD,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,GACpD,QAAQ,CAAC;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEpC;;;;;GAKG;AAEH,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,GAC/C,QAAQ,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGhE,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,GACtD,QAAQ,CAAC;IACP,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnC,SAAS,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACzC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnC,IAAI,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACpC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,UAAU,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC7C,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC1C,CAAC,CAAC;AAEL,2CAA2C;AAE3C,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GACnD,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAG3C,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,OAAO,EAAE,uBAAuB,CAAC;IACjC,SAAS,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC9C,SAAS,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC5C,YAAY,EAAE,SAAS,CAAC,kBAAkB,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;IAC1E,YAAY,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC5C,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC9C,KAAK,EAAE,iBAAiB,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAGH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB,CAAC,CAAC;AA0DH,eAAO,MAAM,oBAAoB;;;;;;;;IAQ/B,iEAAiE;;;IAGjE,wEAAwE;;IAExE,yDAAyD;;IAEzD,sDAAsD;;CAE9C,CAAC;AA8MX;;;;GAIG;AAEH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAA0C,GACnD,MAAM,GAAG,SAAS,CAqDpB;AA0BD,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC,CAAC;AAkCH,4EAA4E;AAE5E,wBAAgB,cAAc,CAC5B,GAAG,EAAE,UAAU,GAAG,SAAS,EAC3B,cAAc,GAAE,MAA4C,GAC3D;IACD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,SAAS,EAAE,OAAO,CAAC;CACpB,CAyGA;AAkDD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,YAAY,CAAC,CAoTvB;AAmED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,QAAQ,GAAE,MAAsC,GAC/C,YAAY,CAmGd"}

package/dist/search-answer.js

@@ -43,6 +43,19 @@ const ROW_KEYS = [
     "approved_by",
     "source",
     "sourceFile",
+    "predicate_namespace",
+    "predicate_name",
+    "predicate_args",
+    "polarity",
+    "subject_key",
+    "property_key",
+    "operator",
+    "value_type",
+    "value_string",
+    "value_int",
+    "value_number",
+    "value_bool",
+    "unit",
 ];
 // implements REQ-kibi-search-answer-layer-v2
 export const SEARCH_ANSWER_LIMITS = {
@@ -52,6 +65,7 @@ export const SEARCH_ANSWER_LIMITS = {
     rationale: 3,
     notGoverning: 5,
     observations: 3,
+    ungoverned: 5,
     /** Entity rows loaded per answer, the matched seeds included. */
     entityLoads: 70,
     maxBytes: 16_384,
@@ -76,6 +90,40 @@ function brief(entity) {
         ...(status ? { status } : {}),
     };
 }
+function queryCall(args) {
+    return `kb_query(${JSON.stringify(args)})`;
+}
+/** Typed statement and follow-up query of a linked fact, by fact kind. */
+// implements REQ-kibi-query-fact-filters
+function factDetail(fact) {
+    const factKind = text(fact.fact_kind);
+    const base = factKind ? { factKind } : {};
+    const predicate = text(fact.predicate_name);
+    if (factKind === "predicate" && predicate) {
+        const args = Array.isArray(fact.predicate_args)
+            ? fact.predicate_args.map(text).join(", ")
+            : text(fact.predicate_args);
+        const polarity = text(fact.polarity) === "deny" ? " [deny]" : "";
+        return {
+            ...base,
+            claim: `${predicate}(${args})${polarity}`,
+            ask: queryCall({ predicate }),
+        };
+    }
+    const subjectKey = text(fact.subject_key);
+    const propertyKey = text(fact.property_key);
+    if (factKind === "property_value" && subjectKey && propertyKey) {
+        const unit = text(fact.unit);
+        const valueType = text(fact.value_type) || "string";
+        const value = text(fact[`value_${valueType}`]);
+        const claim = `${subjectKey} ${propertyKey} ${text(fact.operator) || "eq"} ${value}${unit ? ` ${unit}` : ""}`;
+        return { ...base, claim, ask: queryCall({ subjectKey, propertyKey }) };
+    }
+    if (factKind === "subject" && subjectKey) {
+        return { ...base, claim: subjectKey, ask: queryCall({ subjectKey }) };
+    }
+    return base;
+}
 function edgesGoal(ids) {
     const idList = ids.map((id) => `'${escapeAtom(id)}'`).join(",");
     return `findall([Rel,From,To], (member(Rel, [${ANSWER_RELATIONSHIPS.join(",")}]), kb_relationship(Rel, From, To), (member(From, [${idList}]); member(To, [${idList}]))), Edges)`;
@@ -466,11 +514,12 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
             candidates.set(owner, { score, via });
     };
     const observations = [];
+    const ungoverned = [];
     const rationaleRows = new Map();
     // A matched test may verify a scenario rather than a requirement; its
     // targets are resolved to their governing requirements after the loop.
     const testTargets = [];
-    for (const match of seeds) {
+    for (const [index, match] of seeds.entries()) {
         const id = text(match.entity.id);
         const entity = graph.row(id) ?? match.entity;
         const type = text(entity.type || match.entity.type);
@@ -501,6 +550,18 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
             testTargets.push({ id, score: match.score, targets: owners });
             continue;
         }
+        if (owners.length === 0 && ["fact", "scenario", "symbol"].includes(type)) {
+            if (ungoverned.length < limits.ungoverned)
+                ungoverned.push({
+                    ...brief(entity),
+                    ...(type === "fact" ? factDetail(entity) : {}),
+                    type,
+                    rank: index + 1,
+                });
+            else
+                truncated = true;
+            continue;
+        }
         for (const owner of owners)
             propose(owner, match.score * 0.9, `${type} ${id}`);
     }
@@ -515,6 +576,15 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
     });
     const targetEdges = graph.edgesOf(targetIds);
     for (const test of testTargets) {
+        if (test.targets.length === 0) {
+            const row = graph.row(test.id);
+            const rank = seedIds.indexOf(test.id) + 1;
+            if (row !== null && ungoverned.length < limits.ungoverned)
+                ungoverned.push({ ...brief(row), type: "test", rank });
+            else if (row !== null)
+                truncated = true;
+            continue;
+        }
         for (const target of test.targets) {
             // A target that some requirement specifies is a scenario: lift the
             // test to that requirement. Anything else is a directly verified
@@ -666,10 +736,10 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
             ...brief(req.entity),
             score: req.score,
             via: req.via,
-            facts: rowsOf(plan.facts).map((fact) => {
-                const factKind = text(fact.fact_kind);
-                return { ...brief(fact), ...(factKind ? { factKind } : {}) };
-            }),
+            facts: rowsOf(plan.facts).map((fact) => ({
+                ...brief(fact),
+                ...factDetail(fact),
+            })),
             scenarios: rowsOf(plan.scenarios).map(brief),
             tests: rowsOf(testIds[index] ?? []).map((row) => ({
                 ...brief(row),
@@ -699,20 +769,36 @@ export async function buildSearchAnswer(prolog, matches, options = {}) {
             ? verdicts.scope.syncedAt
             : null,
     };
+    ungoverned.sort((left, right) => left.rank - right.rank);
     const answer = {
         version: "kibi.search-answer.v1",
         governing,
         rationale,
         notGoverning,
         observations: observations.slice(0, limits.observations),
+        ungoverned,
         scope,
         truncated: truncated || graph.truncated,
-        note: governing.length === 0
-            ? "No current requirement matched or owns a matched entity. Absence here is not evidence that nothing governs the change; refine the query or pass sourceLocations."
-            : "Governing requirements are current requirements matched by the query or linked to a matched entity. Links are discovery, not proof. A verdict lists the contradiction and scenario-feasibility witnesses that name the requirement; none means no check named it, not that it is proven. Use kb_check and kb_coverage for consistency and proof status.",
+        note: answerNote(governing.length, ungoverned),
     };
     return fitSearchAnswer(answer, limits.maxBytes);
 }
+// implements REQ-search-answer-hygiene
+/**
+ * How to read the layer. When the top-ranked match is owned by no
+ * requirement, the note says so first: the governing list, if any, came from
+ * lower-ranked matches and is not the top match's requirement.
+ */
+function answerNote(governingCount, ungoverned) {
+    const top = ungoverned.find((entry) => entry.rank === 1);
+    const lead = top === undefined
+        ? ""
+        : `The top-ranked match ${top.id} (${top.type}) is linked to no requirement${governingCount === 0 ? "" : "; the governing requirements below were reached through lower-ranked matches"}. `;
+    return (lead +
+        (governingCount === 0
+            ? "No current requirement matched or owns a matched entity. Absence here is not evidence that nothing governs the change; refine the query or pass sourceLocations."
+            : "Governing requirements are current requirements matched by the query or linked to a matched entity. Links are discovery, not proof. A verdict lists the contradiction and scenario-feasibility witnesses that name the requirement; none means no check named it, not that it is proven. Use kb_check and kb_coverage for consistency and proof status."));
+}
 function byteSize(value) {
     return Buffer.byteLength(JSON.stringify(value), "utf8");
 }
@@ -737,6 +823,7 @@ function withoutExcerpt(entity) {
 const ANSWER_TRIM_ORDER = [
     "observations",
     "notGoverning",
+    "ungoverned",
     "rationale",
 ];
 const REQUIREMENT_TRIM_ORDER = [
@@ -791,6 +878,7 @@ export function fitSearchAnswer(answer, maxBytes = SEARCH_ANSWER_LIMITS.maxBytes
         rationale: current.rationale.map((adr) => clipRationale(adr, titleChars)),
         notGoverning: clipAll(current.notGoverning),
         observations: clipAll(current.observations),
+        ungoverned: clipAll(current.ungoverned),
     };
     // Excerpts are the most expendable text: drop them before any entry.
     for (let index = current.rationale.length - 1; index >= 0 && over(); index -= 1) {

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":"AA0BA,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;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,IAAiB,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAehC;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"}
+{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AA2BA,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;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,IAAiB,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAmBhC;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

@@ -4,7 +4,7 @@
 */
 import { existsSync, readFileSync, readdirSync, statSync, } from "node:fs";
 import * as path from "node:path";
-import { STORE_LOCK_TAKEOVER_VISIBLE_MS, classifyStoreLockHolder, readStoreLockOwner, readStoreLockTakeover, } from "../prolog/store-lock.js";
+import { FOREIGN_STORE_LOCK_REASON_PREFIX, STORE_LOCK_TAKEOVER_VISIBLE_MS, classifyStoreLockHolder, readStoreLockOwner, readStoreLockTakeover, } 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. */
@@ -170,7 +170,9 @@ export function storeLockTakeoverReason(storePath, now = new Date()) {
         brokenPid: record.brokenPid,
         reason: record.reason,
         at: record.at,
-        detail: `Kibi broke a stale branch-store lock at ${record.at} (${record.reason || "holder no longer running"}) and reattached. Nothing needs repair; a holder that died while it held the store usually means an engine or kibi prove run crashed or was killed.`,
+        detail: `Kibi broke a stale branch-store lock at ${record.at} (${record.reason || "holder no longer running"}) and reattached. Nothing needs repair; ${record.reason.startsWith(FOREIGN_STORE_LOCK_REASON_PREFIX)
+            ? "the lock files were copied with the .kb directory (for example by cp -a) while another workspace's engine held its own store."
+            : "a holder that died while it held the store usually means an engine or kibi prove run crashed or was killed."}`,
     };
 }
 export function branchStoreReason(inspection) {

package/dist/utils/content-freshness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content-freshness.d.ts","sourceRoot":"","sources":["../../src/utils/content-freshness.ts"],"names":[],"mappings":"AAYA,uDAAuD;AACvD,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAIxD,CAAC;AAEH,KAAK,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AA6IhD;;;GAGG;AAEH,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAkBvC"}
+{"version":3,"file":"content-freshness.d.ts","sourceRoot":"","sources":["../../src/utils/content-freshness.ts"],"names":[],"mappings":"AAYA,uDAAuD;AACvD,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAIxD,CAAC;AAEH,KAAK,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAyJhD;;;GAGG;AAEH,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAkBvC"}

package/dist/utils/content-freshness.js

@@ -7,7 +7,7 @@ import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
 import { load as parseYAML } from "js-yaml";
 import { hashManifestWithCoordinates } from "../commands/sync/cache.js";
-import { isSymbolsManifestPath } from "./kb-paths.js";
+import { KB_PATHS, isSymbolsManifestPath } from "./kb-paths.js";
 /** Stale-reason codes that compare file times only. */
 export const MTIME_SOURCE_REASON_CODES = new Set([
     "indexed_source_newer",
@@ -35,6 +35,7 @@ function record(value) {
  * source hashes, and the per-symbol `sourceHash` of the generated coordinate
  * artifact. A file whose bytes match that evidence has not changed since it
  * was compiled, however new its mtime (a fresh clone, a checkout, a touch).
+ * Without either kind of evidence a reason is kept.
  */
 class CompiledContentEvidence {
     workspaceRoot;
@@ -85,10 +86,19 @@ class CompiledContentEvidence {
         if (this.coordinateHashes)
             return this.coordinateHashes;
         const byFile = new Map();
+        // The coordinate artifact is content evidence in its own right: kb_upsert
+        // and sync record each symbol's source hash there. Consult the canonical
+        // artifact even when its manifest was never hashed (an untracked,
+        // upsert-only `.kb/symbols.yaml` that sync could not see).
+        const artifacts = new Set([
+            path.resolve(this.workspaceRoot, KB_PATHS.symbolCoordinates),
+        ]);
         for (const key of Object.keys(this.hashes)) {
             if (!isSymbolsManifestPath(key) || !key.endsWith("symbols.yaml"))
                 continue;
-            const artifact = path.resolve(this.workspaceRoot, path.dirname(key), "symbol-coordinates.yaml");
+            artifacts.add(path.resolve(this.workspaceRoot, path.dirname(key), "symbol-coordinates.yaml"));
+        }
+        for (const artifact of artifacts) {
             if (!existsSync(artifact))
                 continue;
             try {

package/dist/utils/symbol-manifest-layout.d.ts

@@ -0,0 +1,9 @@
+import { type Document } from "yaml";
+/**
+ * Render the `symbols` sequence of a parsed manifest, and every collection
+ * inside it, as block YAML. `kibi init` writes `symbols: []`, a flow
+ * sequence, and kibi-cli before 2.18.0 appended to it, so older manifests
+ * keep every symbol on that one line. Returns true when the layout changed.
+ */
+export declare function blockifySymbolManifest(doc: Document): boolean;
+//# sourceMappingURL=symbol-manifest-layout.d.ts.map

package/dist/utils/symbol-manifest-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-manifest-layout.d.ts","sourceRoot":"","sources":["../../src/utils/symbol-manifest-layout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA8B,MAAM,MAAM,CAAC;AAEjE;;;;;GAKG;AAEH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAO7D"}

package/dist/utils/symbol-manifest-layout.js

@@ -0,0 +1,18 @@
+import { isCollection, isSeq, visit } from "yaml";
+/**
+ * Render the `symbols` sequence of a parsed manifest, and every collection
+ * inside it, as block YAML. `kibi init` writes `symbols: []`, a flow
+ * sequence, and kibi-cli before 2.18.0 appended to it, so older manifests
+ * keep every symbol on that one line. Returns true when the layout changed.
+ */
+// implements REQ-kibi-hooks-flow-manifest, REQ-core-persistence
+export function blockifySymbolManifest(doc) {
+    const symbols = doc.get("symbols", true);
+    if (!isSeq(symbols) || symbols.flow !== true)
+        return false;
+    visit(symbols, (_key, node) => {
+        if (isCollection(node))
+            node.flow = false;
+    });
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.18.0",
+  "version": "2.20.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,8 +235,8 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.19.0",
-    "kibi-plugin-builtin": "^0.5.0",
+    "kibi-core": "^0.21.0",
+    "kibi-plugin-builtin": "^0.5.1",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",
     "saxes": "^6.0.0",