kibi-cli 0.14.0 → 0.17.0

package/dist/commands/query.js

@@ -1,169 +1,37 @@
-/*
- Kibi — repo-local, per-branch, queryable long-term memory for software projects
- Copyright (C) 2026 Piotr Franczyk
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-import * as path from "node:path";
 import Table from "cli-table3";
-import { PrologProcess } from "../prolog.js";
-import { parseEntityFromBinding, parseEntityFromList, parseListOfLists, parsePrologValue, } from "../prolog/codec.js";
+import { parseListOfLists, parsePrologValue } from "../prolog/codec.js";
+import { VALID_ENTITY_TYPES, executeOperation, querySpec, } from "../public/operations/index.js";
 import relationshipSchema from "../public/schemas/relationship.js";
-import { VALID_ENTITY_TYPES } from "../query/service.js";
-import { resolveActiveBranch } from "../utils/branch-resolver.js";
-import { safeCleanupProlog } from "../utils/prolog-cleanup.js";
+import { createCliRuntime } from "../runtime/cli-runtime.js";
+import { withAttachedBranchProlog } from "./discovery-shared.js";
 const REL_TYPES = relationshipSchema.properties.type.enum;
-// implements REQ-003
 export async function queryCommand(type, options) {
-    let prolog = null;
-    let attached = false;
+    // implements REQ-003, REQ-kibi-operation-interface-parity
+    if (!type && !options.source && !options.relationships) {
+        console.error("Error: Must specify entity type, --source, or --relationships option");
+        return { exitCode: 1 };
+    }
+    if (type && !VALID_ENTITY_TYPES.some((candidate) => candidate === type)) {
+        console.error(`Error: Invalid type '${type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}`);
+        return { exitCode: 1 };
+    }
     try {
-        prolog = new PrologProcess({ timeout: 120000 });
-        await prolog.start();
-        await prolog.query("set_prolog_flag(answer_write_options, [max_depth(0), spacing(next_argument)])");
-        let currentBranch;
-        const branchResult = resolveActiveBranch();
-        if ("error" in branchResult) {
-            const isNonGitError = branchResult.code === "NOT_A_GIT_REPO" ||
-                branchResult.code === "GIT_NOT_AVAILABLE";
-            if (isNonGitError) {
-                // For query command, use "main" as default branch when git is not available
-                // or the current directory is not a git repository. This allows querying
-                // after init in a non-git directory.
-                currentBranch = "main";
-            }
-            else {
-                console.error(`Error: Failed to resolve active branch:\n${branchResult.error}`);
-                await prolog.terminate();
-                return { exitCode: 1 };
-            }
-        }
-        else {
-            currentBranch = branchResult.branch;
-        }
-        const kbPath = path.join(process.cwd(), `.kb/branches/${currentBranch}`);
-        const attachResult = await prolog.query(`kb_attach('${kbPath}')`);
-        if (!attachResult.success) {
-            await prolog.terminate();
-            console.error(`Error: Failed to attach KB: ${attachResult.error || "Unknown error"}`);
-            return { exitCode: 1 };
-        }
-        attached = true;
-        let results = [];
+        const limit = Number.parseInt(options.limit || "100", 10);
+        const offset = Number.parseInt(options.offset || "0", 10);
         if (options.relationships) {
-            const fromId = String(options.relationships);
-            const safeFromId = fromId.replace(/'/g, "''");
-            const relTypesList = REL_TYPES.join(", ");
-            const goal = `findall([Type,From,To], (member(Type, [${relTypesList}]), kb_relationship(Type, '${safeFromId}', To), From='${safeFromId}'), Results)`;
-            const queryResult = await prolog.query(goal);
-            if (queryResult.success && queryResult.bindings.Results) {
-                const rows = parseListOfLists(queryResult.bindings.Results);
-                const parsed = rows
-                    .filter((r) => r.length >= 3)
-                    .flatMap((r) => {
-                    const [typeValue, fromValue, toValue] = r;
-                    if (typeValue === undefined ||
-                        fromValue === undefined ||
-                        toValue === undefined) {
-                        return [];
-                    }
-                    return [
-                        {
-                            type: parsePrologValue(typeValue),
-                            from: parsePrologValue(fromValue),
-                            to: parsePrologValue(toValue),
-                        },
-                    ];
-                });
-                results = parsed.filter((rel) => rel &&
-                    typeof rel.type === "string" &&
-                    typeof rel.from === "string" &&
-                    typeof rel.to === "string" &&
-                    rel.from === fromId &&
-                    REL_TYPES.includes(rel.type));
-            }
-        }
-        else if (type || options.source) {
-            if (type && !VALID_ENTITY_TYPES.includes(type)) {
-                console.error(`Error: Invalid type '${type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}`);
-                return { exitCode: 1 };
-            }
-            let goal;
-            if (options.source) {
-                const safeSource = String(options.source).replace(/'/g, "\\'");
-                if (type) {
-                    goal = `findall([Id,'${type}',Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, '${type}', Props)), Results)`;
-                }
-                else {
-                    goal = `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;
-                }
-            }
-            else if (options.id) {
-                const safeId = String(options.id).replace(/'/g, "''");
-                goal = `kb_entity('${safeId}', '${type}', Props), Id = '${safeId}', Type = '${type}', Result = [Id, Type, Props]`;
-            }
-            else if (options.tag) {
-                const safeTag = String(options.tag).replace(/'/g, "''");
-                goal = `findall([Id,'${type}',Props], (kb_entity(Id, '${type}', Props), memberchk(tags=Tags, Props), member('${safeTag}', Tags)), Results)`;
-            }
-            else {
-                goal = `findall([Id,'${type}',Props], kb_entity(Id, '${type}', Props), Results)`;
-            }
-            const queryResult = await prolog.query(goal);
-            if (queryResult.success) {
-                if (options.id) {
-                    // Single entity query
-                    if (queryResult.bindings.Result) {
-                        const entity = parseEntityFromBinding(queryResult.bindings.Result);
-                        results = [entity];
-                    }
-                }
-                else {
-                    // Multiple entities query
-                    if (queryResult.bindings.Results) {
-                        const entitiesData = parseListOfLists(queryResult.bindings.Results);
-                        for (const data of entitiesData) {
-                            const entity = parseEntityFromList(data);
-                            results.push(entity);
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            console.error("Error: Must specify entity type, --source, or --relationships option");
-            return { exitCode: 1 };
-        }
-        const limit = Number.parseInt(options.limit || "100");
-        const offset = Number.parseInt(options.offset || "0");
-        const paginated = results.slice(offset, offset + limit);
-        if (!paginated || paginated.length === 0) {
-            if (options.format === "json") {
-                console.log("[]");
-            }
-            else {
-                console.log("No entities found");
-            }
+            const relationships = await queryRelationships(options.relationships);
+            printRelationships(relationships.slice(offset, offset + limit), options.format);
             return { exitCode: 0 };
         }
-        // Format output
-        if (options.format === "table") {
-            outputTable(paginated, Boolean(options.relationships));
-        }
-        else {
-            console.log(JSON.stringify(paginated, null, 2));
-        }
+        const result = await executeOperation(createCliRuntime(), querySpec, {
+            ...(type !== undefined ? { type } : {}),
+            ...(options.id !== undefined ? { id: options.id } : {}),
+            ...(options.tag !== undefined ? { tags: [options.tag] } : {}),
+            ...(options.source !== undefined ? { sourceFile: options.source } : {}),
+            limit,
+            offset,
+        }, { workspaceRoot: process.cwd() });
+        printEntities(result.structuredContent?.entities ?? [], options.format);
         return { exitCode: 0 };
     }
     catch (error) {
@@ -171,57 +39,83 @@ export async function queryCommand(type, options) {
         console.error(`Error: ${message}`);
         return { exitCode: 1 };
     }
-    finally {
-        await safeCleanupProlog(prolog);
+}
+async function queryRelationships(fromId) {
+    return withAttachedBranchProlog(async (prolog) => {
+        const safeFromId = fromId.replaceAll("'", "''");
+        const goal = `findall([Type,From,To], (member(Type, [${REL_TYPES.join(", ")}]), kb_relationship(Type, '${safeFromId}', To), From='${safeFromId}'), Results)`;
+        const result = await prolog.query(goal);
+        const binding = result.bindings.Results;
+        if (!result.success || !binding)
+            return [];
+        return parseListOfLists(binding).flatMap((row) => {
+            const [typeValue, fromValue, toValue] = row;
+            if (!typeValue || !fromValue || !toValue)
+                return [];
+            const type = parsePrologValue(typeValue);
+            const from = parsePrologValue(fromValue);
+            const to = parsePrologValue(toValue);
+            if (typeof type !== "string" ||
+                typeof from !== "string" ||
+                typeof to !== "string" ||
+                from !== fromId ||
+                !REL_TYPES.includes(type)) {
+                return [];
+            }
+            return [{ type, from, to }];
+        });
+    });
+}
+function printRelationships(items, format) {
+    if (items.length === 0) {
+        console.log(format === "json" ? "[]" : "No entities found");
+        return;
+    }
+    if (format !== "table") {
+        console.log(JSON.stringify(items, null, 2));
+        return;
     }
+    const table = new Table({
+        head: ["Type", "From", "To"],
+        colWidths: [20, 18, 18],
+    });
+    for (const item of items) {
+        table.push([
+            item.type || "N/A",
+            item.from.substring(0, 16) || "N/A",
+            item.to.substring(0, 16) || "N/A",
+        ]);
+    }
+    console.log(table.toString());
 }
-/**
- * Output results as a formatted table.
- */
-function outputTable(items, isRelationships) {
+function printEntities(items, format) {
     if (items.length === 0) {
-        console.log("No entities found.");
+        console.log(format === "json" ? "[]" : "No entities found");
         return;
     }
-    if (isRelationships) {
-        const table = new Table({
-            head: ["Type", "From", "To"],
-            colWidths: [20, 18, 18],
-        });
-        for (const item of items) {
-            const rel = item;
-            table.push([
-                rel.type || "N/A",
-                rel.from.substring(0, 16) || "N/A",
-                rel.to.substring(0, 16) || "N/A",
-            ]);
-        }
-        console.log(table.toString());
+    if (format !== "table") {
+        console.log(JSON.stringify(items, null, 2));
+        return;
     }
-    else {
-        const table = new Table({
-            head: ["ID", "Type", "Title", "Status", "Tags"],
-            colWidths: [18, 10, 40, 12, 30],
-        });
-        for (const entity of items) {
-            const record = entity;
-            const id = typeof record.id === "string" ? record.id : "N/A";
-            const entityType = typeof record.type === "string" ? record.type : "N/A";
-            const title = typeof record.title === "string" ? record.title : "N/A";
-            const status = typeof record.status === "string" ? record.status : "N/A";
-            const tags = Array.isArray(record.tags)
-                ? record.tags
-                    .filter((tag) => typeof tag === "string")
-                    .join(", ")
-                : "";
-            table.push([
-                id.substring(0, 16),
-                entityType,
-                title.substring(0, 38),
-                status,
-                tags.substring(0, 28),
-            ]);
-        }
-        console.log(table.toString());
+    const table = new Table({
+        head: ["ID", "Type", "Title", "Status", "Tags"],
+        colWidths: [18, 10, 40, 12, 30],
+    });
+    for (const item of items) {
+        const id = typeof item.id === "string" ? item.id : "N/A";
+        const entityType = typeof item.type === "string" ? item.type : "N/A";
+        const title = typeof item.title === "string" ? item.title : "N/A";
+        const status = typeof item.status === "string" ? item.status : "N/A";
+        const tags = Array.isArray(item.tags)
+            ? item.tags.filter((tag) => typeof tag === "string").join(", ")
+            : "";
+        table.push([
+            id.substring(0, 16),
+            entityType,
+            title.substring(0, 38),
+            status,
+            tags.substring(0, 28),
+        ]);
     }
+    console.log(table.toString());
 }

package/dist/commands/search.d.ts

@@ -1,8 +1,8 @@
 interface SearchOptions {
-    type?: string;
-    format?: "json" | "table";
-    limit?: string;
-    offset?: string;
+    readonly type?: string;
+    readonly format?: "json" | "table";
+    readonly limit?: string;
+    readonly offset?: string;
 }
 export declare function searchCommand(query: string | undefined, options: SearchOptions): Promise<void>;
 export {};

package/dist/commands/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/commands/search.ts"],"names":[],"mappings":"AASA,UAAU,aAAa;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CA+Bf"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/commands/search.ts"],"names":[],"mappings":"AAQA,UAAU,aAAa;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAmCf"}

package/dist/commands/search.js

@@ -1,38 +1,25 @@
-import { VALID_ENTITY_TYPES, queryEntities } from "../query/service.js";
-import { rankEntities } from "../search-ranking.js";
-import { printDiscoveryResult, withAttachedBranchProlog, } from "./discovery-shared.js";
-// implements REQ-mcp-search-discovery, REQ-003
+import { VALID_ENTITY_TYPES, executeOperation, searchSpec, } from "../public/operations/index.js";
+import { createCliRuntime } from "../runtime/cli-runtime.js";
+import { printDiscoveryResult } from "./discovery-shared.js";
 export async function searchCommand(query, options) {
+    // implements REQ-003, REQ-kibi-operation-interface-parity
     if (!query?.trim()) {
         console.error("Error: search query is required");
         process.exitCode = 1;
         return;
     }
-    if (options.type && !VALID_ENTITY_TYPES.includes(options.type)) {
+    if (options.type &&
+        !VALID_ENTITY_TYPES.some((candidate) => candidate === options.type)) {
         console.error(`Error: invalid type '${options.type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}`);
         process.exitCode = 1;
         return;
     }
-    await withAttachedBranchProlog(async (prolog) => {
-        const limit = Number.parseInt(options.limit || "20", 10);
-        const offset = Number.parseInt(options.offset || "0", 10);
-        const result = await executeSearch(prolog, query, options.type, limit, offset);
-        printDiscoveryResult(options.format, result, buildSearchText(query, result));
-    });
-}
-async function executeSearch(prolog, query, type, limit, offset) {
-    const entitiesResult = await queryEntities(prolog, {
-        ...(type !== undefined ? { type } : {}),
-        limit: 100000,
-        offset: 0,
-    });
-    const matches = await rankEntities(entitiesResult.entities, query, process.cwd());
-    const paginated = matches.slice(offset, offset + limit);
-    return { results: paginated, count: matches.length };
-}
-function buildSearchText(query, result) {
-    if (result.count === 0) {
-        return `No search results for '${query}'.`;
-    }
-    return `Found ${result.count} search results for '${query}'. Showing ${result.results.length}: ${result.results.map((match) => match.entity.id).join(", ")}`;
+    const result = await executeOperation(createCliRuntime(), searchSpec, {
+        query,
+        ...(options.type !== undefined ? { type: options.type } : {}),
+        limit: Number.parseInt(options.limit || "20", 10),
+        offset: Number.parseInt(options.offset || "0", 10),
+    }, { workspaceRoot: process.cwd() });
+    const structured = result.structuredContent ?? { results: [], count: 0 };
+    printDiscoveryResult(options.format, structured, result.content[0]?.text ?? `No search results for '${query}'.`);
 }

package/dist/commands/status.d.ts

@@ -1,5 +1,5 @@
 interface StatusOptions {
-    format?: "json" | "table";
+    readonly format?: "json" | "table";
 }
 export declare function statusCommand(options: StatusOptions): Promise<void>;
 export {};

package/dist/commands/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAOA,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBzE"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAIA,UAAU,aAAa;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACpC;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAazE"}

package/dist/commands/status.js

@@ -1,9 +1,8 @@
-import { printDiscoveryResult, resolveCurrentKbPath, runJsonModuleQuery, withPrologProcess, } from "./discovery-shared.js";
-// implements REQ-002, REQ-003
+import { executeOperation, statusSpec } from "../public/operations/index.js";
+import { createCliRuntime } from "../runtime/cli-runtime.js";
+import { printDiscoveryResult } from "./discovery-shared.js";
 export async function statusCommand(options) {
-    await withPrologProcess(async (prolog) => {
-        const kbPath = await resolveCurrentKbPath();
-        const result = await runJsonModuleQuery(prolog, "status.pl", "status:kb_status_json(JsonString)", "status query failed", kbPath);
-        printDiscoveryResult(options.format, result, `Branch ${result.branch} is ${result.syncState} (dirty=${result.dirty})`);
-    });
+    // implements REQ-003, REQ-kibi-operation-interface-parity
+    const result = await executeOperation(createCliRuntime(), statusSpec, {}, { workspaceRoot: process.cwd() });
+    printDiscoveryResult(options.format, result.structuredContent, result.content[0]?.text ?? "Status unavailable");
 }

package/dist/commands/sync/manifest.d.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dump as dumpYAML, load as parseYAML } from "js-yaml";
 import { writeCoordinateArtifact } from "../../extractors/symbol-coordinates.js";
 import { type ManifestSymbolEntry, enrichSymbolCoordinates } from "../../extractors/symbols-coordinator.js";
+import { COARSE_GRANULARITY_REASONS } from "../../public/symbol-granularity.js";
 import { resolveSymbolsManifestPaths } from "../../utils/manifest-paths.js";
 interface ManifestDeps {
     dumpYAML: typeof dumpYAML;
@@ -13,11 +14,21 @@ interface ManifestDeps {
     writeCoordinateArtifact: typeof writeCoordinateArtifact;
     resolveSymbolsManifestPaths: typeof resolveSymbolsManifestPaths;
 }
-export declare const SYMBOLS_MANIFEST_COMMENT_BLOCK = "# symbols.yaml\n# AUTHORED fields (edit freely):\n#   id, title, sourceFile, links, status, tags, owner, priority\n# GENERATED fields (never edit manually \u2014 overwritten by kibi sync and kb.symbols.refresh):\n#   sourceLine, sourceColumn, sourceEndLine, sourceEndColumn\n# Run `kibi sync` or call the `kb.symbols.refresh` MCP tool to refresh coordinates.\n";
+export declare const SYMBOLS_MANIFEST_COMMENT_BLOCK = "# symbols.yaml\n# AUTHORED fields (edit freely):\n#   id, title, sourceFile, links, status, tags, owner, priority\n# Generated coordinates are stored separately in symbol-coordinates.yaml.\n# Run `kibi sync --refresh-symbol-coordinates` to refresh them.\n";
+/**
+ * Coarse symbol anchors for which per-symbol coordinates are not expected.
+ *
+ * Test-suite, module-level-behavior, and config-artifact symbols represent a
+ * whole file or configuration unit, and `extractor-miss` explicitly documents
+ * that the extractor cannot locate a declaration. These entries legitimately
+ * carry no generated coordinates, so coordinate refresh counts them as
+ * unchanged instead of flagging them as failures.
+ */
+export { COARSE_GRANULARITY_REASONS };
+export declare function isCoarseGranularityAnchor(entry: ManifestSymbolEntry): boolean;
 export declare function refreshManifestCoordinates(manifestPath: string, workspaceRoot: string, deps?: Partial<ManifestDeps> & {
     refreshSymbolCoordinates?: boolean;
 }): Promise<void>;
 export declare function hasAllGeneratedCoordinates(entry: ManifestSymbolEntry): boolean;
 export declare function isEligibleForCoordinateRefresh(sourceFile: string | undefined, workspaceRoot: string, deps?: Partial<ManifestDeps>): boolean;
-export {};
 //# sourceMappingURL=manifest.d.ts.map

package/dist/commands/sync/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/manifest.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAElE,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,SAAS,CAAC;AAC9D,OAAO,EAEL,uBAAuB,EACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,mBAAmB,EACxB,uBAAuB,EACxB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,UAAU,YAAY;IACpB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,uBAAuB,EAAE,OAAO,uBAAuB,CAAC;IACxD,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,uBAAuB,EAAE,OAAO,uBAAuB,CAAC;IACxD,2BAA2B,EAAE,OAAO,2BAA2B,CAAC;CACjE;AAgBD,eAAO,MAAM,8BAA8B,6WAM1C,CAAC;AAoBF,wBAAsB,0BAA0B,CAE9C,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG;IAAE,wBAAwB,CAAC,EAAE,OAAO,CAAA;CAAE,GACpE,OAAO,CAAC,IAAI,CAAC,CA0If;AAED,wBAAgB,0BAA0B,CAExC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAOT;AAED,wBAAgB,8BAA8B,CAE5C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,OAAO,CAUT"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/manifest.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAElE,OAAO,EAAE,IAAI,IAAI,QAAQ,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,SAAS,CAAC;AAC9D,OAAO,EAEL,uBAAuB,EACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,mBAAmB,EACxB,uBAAuB,EACxB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,0BAA0B,EAE3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,UAAU,YAAY;IACpB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,uBAAuB,EAAE,OAAO,uBAAuB,CAAC;IACxD,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,uBAAuB,EAAE,OAAO,uBAAuB,CAAC;IACxD,2BAA2B,EAAE,OAAO,2BAA2B,CAAC;CACjE;AAgBD,eAAO,MAAM,8BAA8B,oQAK1C,CAAC;AAwBF;;;;;;;;GAQG;AACH,OAAO,EAAE,0BAA0B,EAAE,CAAC;AAEtC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAG7E;AAED,wBAAsB,0BAA0B,CAE9C,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG;IAAE,wBAAwB,CAAC,EAAE,OAAO,CAAA;CAAE,GACpE,OAAO,CAAC,IAAI,CAAC,CAuIf;AAED,wBAAgB,0BAA0B,CAExC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAOT;AAED,wBAAgB,8BAA8B,CAE5C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,OAAO,CAUT"}

package/dist/commands/sync/manifest.js

@@ -20,6 +20,7 @@ import * as path from "node:path";
 import { dump as dumpYAML, load as parseYAML } from "js-yaml";
 import { writeCoordinateArtifact, } from "../../extractors/symbol-coordinates.js";
 import { enrichSymbolCoordinates, } from "../../extractors/symbols-coordinator.js";
+import { COARSE_GRANULARITY_REASONS, isCoarseGranularityReason, } from "../../public/symbol-granularity.js";
 import { resolveSymbolsManifestPaths } from "../../utils/manifest-paths.js";
 function resolveDeps(overrides) {
     return {
@@ -37,9 +38,8 @@ function resolveDeps(overrides) {
 export const SYMBOLS_MANIFEST_COMMENT_BLOCK = `# symbols.yaml
 # AUTHORED fields (edit freely):
 #   id, title, sourceFile, links, status, tags, owner, priority
-# GENERATED fields (never edit manually — overwritten by kibi sync and kb.symbols.refresh):
-#   sourceLine, sourceColumn, sourceEndLine, sourceEndColumn
-# Run \`kibi sync\` or call the \`kb.symbols.refresh\` MCP tool to refresh coordinates.
+# Generated coordinates are stored separately in symbol-coordinates.yaml.
+# Run \`kibi sync --refresh-symbol-coordinates\` to refresh them.
 `;
 const SYMBOL_COORD_EXTENSIONS = new Set([
     ".ts",
@@ -57,6 +57,24 @@ const GENERATED_COORD_FIELDS = [
     "sourceEndLine",
     "sourceEndColumn",
 ];
+const GENERATED_MANIFEST_FIELDS = new Set([
+    ...GENERATED_COORD_FIELDS,
+    "coordinatesGeneratedAt",
+]);
+/**
+ * Coarse symbol anchors for which per-symbol coordinates are not expected.
+ *
+ * Test-suite, module-level-behavior, and config-artifact symbols represent a
+ * whole file or configuration unit, and `extractor-miss` explicitly documents
+ * that the extractor cannot locate a declaration. These entries legitimately
+ * carry no generated coordinates, so coordinate refresh counts them as
+ * unchanged instead of flagging them as failures.
+ */
+export { COARSE_GRANULARITY_REASONS };
+export function isCoarseGranularityAnchor(entry) {
+    const reason = entry.granularity_reason;
+    return isCoarseGranularityReason(reason);
+}
 export async function refreshManifestCoordinates(
 // implements REQ-003
 manifestPath, workspaceRoot, deps) {
@@ -108,20 +126,9 @@ manifestPath, workspaceRoot, deps) {
             console.warn(`Warning: Failed to write symbol-coordinates artifact: ${String(err)}`);
         }
     }
-    // Strip generated fields from symbols.yaml entries only if original had them
-    const strippedEnriched = enriched.map((current, idx) => {
-        const prev = before[idx] ?? {};
-        const out = { ...current };
-        const originalHadGenerated = GENERATED_COORD_FIELDS.some((f) => prev[f] !== undefined);
-        if (originalHadGenerated) {
-            for (const field of GENERATED_COORD_FIELDS) {
-                delete out[field];
-            }
-        }
-        // Ensure we never write coordinatesGeneratedAt
-        out.coordinatesGeneratedAt = undefined;
-        return out;
-    });
+    // Coordinates belong exclusively to the generated artifact. Always strip
+    // them from the authored manifest so consecutive refreshes are idempotent.
+    const strippedEnriched = enriched.map((current) => Object.fromEntries(Object.entries(current).filter(([field]) => !GENERATED_MANIFEST_FIELDS.has(field))));
     parsed.symbols = strippedEnriched;
     let refreshed = 0;
     let failed = 0;
@@ -135,11 +142,13 @@ manifestPath, workspaceRoot, deps) {
             refreshed++;
             continue;
         }
-        const eligible = isEligibleForCoordinateRefresh(typeof current.sourceFile === "string"
-            ? current.sourceFile
-            : typeof previous.sourceFile === "string"
-                ? previous.sourceFile
-                : undefined, workspaceRoot, resolved);
+        const coarseAnchor = isCoarseGranularityAnchor(current);
+        const eligible = !coarseAnchor &&
+            isEligibleForCoordinateRefresh(typeof current.sourceFile === "string"
+                ? current.sourceFile
+                : typeof previous.sourceFile === "string"
+                    ? previous.sourceFile
+                    : undefined, workspaceRoot, resolved);
         if (eligible && !hasAllGeneratedCoordinates(current)) {
             failed++;
         }

package/dist/commands/sync/persistence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/persistence.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAEV,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA0ErD,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB;AAmCD,wBAAsB,eAAe,CAEnC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CAoFvD;AA6BD,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,kBAAkB,EAAE,qBAAqB,EAAE,GAC1C,OAAO,CAAC;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CA+K7D"}
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/persistence.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAEV,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA8GrD,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB;AAmCD,wBAAsB,eAAe,CAEnC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CA8FvD;AA6BD,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,kBAAkB,EAAE,qBAAqB,EAAE,GAC1C,OAAO,CAAC;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CA+K7D"}

package/dist/commands/sync/persistence.js

@@ -36,9 +36,31 @@ const STRING_FIELDS = new Set([
     "valid_from",
     "valid_to",
     "canonical_key",
+    "claim_key",
+    "claim_text",
+    "predicate_name",
+    "predicate_namespace",
+    "rule_hash",
+    "rule_schema_id",
+    "rule_name",
+    "semantic_key",
+]);
+const NUMBER_FIELDS = new Set([
+    "value_int",
+    "value_number",
+    "predicate_arity",
+    "claim_span_start",
+    "claim_span_end",
 ]);
-const NUMBER_FIELDS = new Set(["value_int", "value_number"]);
 const BOOLEAN_FIELDS = new Set(["value_bool", "closed_world"]);
+const STRING_ARRAY_FIELDS = new Set([
+    "argument_names",
+    "argument_types",
+    "argument_descriptions",
+    "aliases",
+    "examples",
+    "predicate_args",
+]);
 function getEntityField(entity, field) {
     // ExtractedEntity declares all fact fields as optional properties, so indexing
     // via keyof is safe. The cast is confined to this single helper.
@@ -54,6 +76,10 @@ function serializeTypedFactFields(entity) {
             fields.push(`${field}=${toPrologString(String(value))}`);
         }
     }
+    const ruleIr = getEntityField(entity, "rule_ir");
+    if (ruleIr !== undefined && ruleIr !== null) {
+        fields.push(`rule_ir=${toPrologString(JSON.stringify(ruleIr))}`);
+    }
     // Atom fields (possibly unquoted if simple)
     for (const field of ATOM_FIELDS) {
         const value = getEntityField(entity, field);
@@ -78,6 +104,12 @@ function serializeTypedFactFields(entity) {
             fields.push(`${field}=${value}`);
         }
     }
+    for (const field of STRING_ARRAY_FIELDS) {
+        const value = getEntityField(entity, field);
+        if (Array.isArray(value)) {
+            fields.push(`${field}=[${value.map((item) => toPrologString(String(item))).join(",")}]`);
+        }
+    }
     return fields;
 }
 function isQueryFailedError(error) {
@@ -147,6 +179,12 @@ prolog, results, entityIds) {
                 props.push(`severity=${toPrologAtom(entity.severity)}`);
             if (entity.text_ref)
                 props.push(`text_ref=${toPrologString(entity.text_ref)}`);
+            if (entity.type === "req" && entity.logic_claims) {
+                props.push(`logic_claims=[${entity.logic_claims.map(toPrologAtom).join(",")}]`);
+            }
+            if (entity.type === "req" && entity.semantic_inventory) {
+                props.push(`semantic_inventory=${toPrologString(JSON.stringify(entity.semantic_inventory))}`);
+            }
             if (sourceFile)
                 props.push(`sourceFile=${toPrologString(sourceFile)}`);
             // Add typed fact fields for fact entities