kibi-cli 0.4.3 → 0.5.1

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

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AA4CA,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EAAE,SAAS,EAAE,CAAC;AAK1B,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAGD,wBAAsB,YAAY,CAChC,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA0R/B"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/commands/check.ts"],"names":[],"mappings":"AAmDA,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EAAE,SAAS,EAAE,CAAC;AAI1B,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAmGD,wBAAsB,YAAY,CAChC,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgR/B"}

package/dist/commands/check.js

@@ -15,21 +15,96 @@
  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 { existsSync } from "node:fs";
 import * as path from "node:path";
-import { extractFromManifest } from "../extractors/manifest.js";
+import { extractFromManifest, extractFromManifestString } from "../extractors/manifest.js";
+import { extractFromMarkdownString, } from "../extractors/markdown.js";
 import { PrologProcess } from "../prolog.js";
 import { escapeAtom, parseTriples, parseViolationRows, } from "../prolog/codec.js";
 import { getStagedFiles } from "../traceability/git-staged.js";
 import { validateStagedMarkdown } from "../traceability/markdown-validate.js";
-import { extractSymbolsFromStagedFile, } from "../traceability/symbol-extract.js";
-import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb, } from "../traceability/temp-kb.js";
+import { createManifestLookupSentinelKey, extractSymbolsFromStagedFile, } from "../traceability/symbol-extract.js";
+import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb, projectStagedEntities, } from "../traceability/temp-kb.js";
 import { formatViolations as formatStagedViolations, validateStagedSymbols, } from "../traceability/validate.js";
 import { loadConfig } from "../utils/config.js";
 import { safeCleanupProlog } from "../utils/prolog-cleanup.js";
 import { RULES, getEffectiveRules, } from "../utils/rule-registry.js";
 import { runAggregatedChecks } from "./aggregated-checks.js";
 import { getCurrentBranch } from "./init-helpers.js";
-import { discoverSourceFiles } from "./sync/discovery.js";
+function buildManifestLookup(stagedFiles) {
+    const manifestLookup = new Map();
+    const manifestResults = [];
+    // Pre-populate lookup from working-tree manifests so that code-only changes
+    // (where symbols.yaml is not staged) still resolve to the correct symbol IDs
+    // and relationships already defined on disk.
+    const config = loadConfig(process.cwd());
+    const symbolsRelPath = config.paths.symbols;
+    if (symbolsRelPath) {
+        const absSymbolsPath = path.resolve(process.cwd(), symbolsRelPath);
+        if (existsSync(absSymbolsPath)) {
+            try {
+                const entries = extractFromManifest(absSymbolsPath);
+                for (const entry of entries) {
+                    const sourceFile = entry.sourceFile || entry.entity.source || absSymbolsPath;
+                    const key = `${sourceFile}:${entry.entity.title}`;
+                    manifestLookup.set(key, {
+                        id: entry.entity.id,
+                        relationships: entry.relationships
+                            .filter((relationship) => relationship.type === "implements" ||
+                            relationship.type === "covered_by")
+                            .map((relationship) => ({
+                            type: relationship.type,
+                            to: relationship.to,
+                        })),
+                    });
+                }
+            }
+            catch (e) {
+                // Ignore working-tree manifest parsing errors; staged-only fallback still applies
+                if (process.env.KIBI_TRACE || process.env.KIBI_DEBUG) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    console.debug(`[kibi] skipping working-tree manifest ${absSymbolsPath}: ${msg}`);
+                }
+            }
+        }
+    }
+    const stagedManifestFiles = stagedFiles.filter((file) => file.content !== undefined &&
+        (file.path.endsWith("/symbols.yaml") ||
+            file.path.endsWith("/symbols.yml") ||
+            file.path === "symbols.yaml" ||
+            file.path === "symbols.yml"));
+    for (const manifestFile of stagedManifestFiles) {
+        manifestLookup.set(createManifestLookupSentinelKey(manifestFile.path), {
+            id: manifestFile.path,
+            relationships: [],
+        });
+        try {
+            const entries = extractFromManifestString(manifestFile.content ?? "", manifestFile.path);
+            for (const entry of entries) {
+                manifestResults.push({
+                    entity: entry.entity,
+                    relationships: entry.relationships,
+                });
+                const sourceFile = entry.sourceFile || entry.entity.source || manifestFile.path;
+                const key = `${sourceFile}:${entry.entity.title}`;
+                manifestLookup.set(key, {
+                    id: entry.entity.id,
+                    relationships: entry.relationships
+                        .filter((relationship) => relationship.type === "implements" ||
+                        relationship.type === "covered_by")
+                        .map((relationship) => ({
+                        type: relationship.type,
+                        to: relationship.to,
+                    })),
+                });
+            }
+        }
+        catch {
+            // Ignore manifest parsing errors
+        }
+    }
+    return { manifestLookup, manifestResults };
+}
 // implements REQ-006
 export async function checkCommand(options) {
     let prolog = null;
@@ -59,33 +134,12 @@ export async function checkCommand(options) {
             const minLinks = options.minLinks ? Number(options.minLinks) : 1;
             let tempCtx = null;
             try {
-                const config = loadConfig(process.cwd());
-                const manifestLookup = new Map();
-                const { manifestFiles } = await discoverSourceFiles(process.cwd(), config.paths);
-                for (const manifestPath of manifestFiles) {
-                    try {
-                        const entries = extractFromManifest(manifestPath);
-                        for (const entry of entries) {
-                            // Prefer the per-symbol sourceFile; fall back to entity.source or manifest path
-                            const sourceFile = entry.sourceFile || entry.entity.source || manifestPath;
-                            const key = `${sourceFile}:${entry.entity.title}`;
-                            // Extract requirement links (implements relationships to REQ-*)
-                            const links = entry.relationships
-                                .filter((r) => r.type === "implements" &&
-                                r.to.match(/^[A-Z][A-Z0-9\-_]*$/))
-                                .map((r) => r.to);
-                            manifestLookup.set(key, { id: entry.entity.id, links });
-                        }
-                    }
-                    catch {
-                        // Ignore manifest parsing errors
-                    }
-                }
                 const stagedFiles = getStagedFiles();
                 if (!stagedFiles || stagedFiles.length === 0) {
                     console.log("No staged files found.");
                     return { exitCode: 0 };
                 }
+                const { manifestLookup, manifestResults } = buildManifestLookup(stagedFiles);
                 const codeFiles = stagedFiles.filter((f) => !f.path.endsWith(".md"));
                 const markdownFiles = stagedFiles.filter((f) => f.path.endsWith(".md"));
                 const markdownErrors = [];
@@ -118,8 +172,13 @@ export async function checkCommand(options) {
                         console.error(`Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`);
                     }
                 }
-                if (allSymbols.length === 0 && markdownFiles.length === 0) {
-                    console.log("No exported symbols or markdown entities found in staged files.");
+                const markdownResults = markdownFiles.map((file) => extractFromMarkdownString(file.content ?? "", file.path));
+                const stagedEntityResults = [
+                    ...manifestResults,
+                    ...markdownResults,
+                ];
+                if (allSymbols.length === 0 && stagedEntityResults.length === 0) {
+                    console.log("No exported symbols or staged entities found in staged files.");
                     return { exitCode: 0 };
                 }
                 if (allSymbols.length === 0) {
@@ -128,9 +187,13 @@ export async function checkCommand(options) {
                 }
                 // Create temp KB
                 tempCtx = await createTempKb(resolvedKbPath);
+                if (stagedEntityResults.length > 0) {
+                    await projectStagedEntities(tempCtx.prolog, stagedEntityResults);
+                }
                 const overlayFacts = createOverlayFacts(allSymbols);
                 const fs = await import("node:fs/promises");
                 await fs.writeFile(tempCtx.overlayPath, overlayFacts, "utf8");
+                await fs.cp(tempCtx.overlayPath, path.join(tempCtx.kbPath, "changed_symbols.pl"));
                 await consultOverlay(tempCtx);
                 const violationsRaw = await validateStagedSymbols({
                     minLinks,

package/dist/commands/init-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AAmFA,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAYf;AASD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAmCnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiBpD"}
+{"version":3,"file":"init-helpers.d.ts","sourceRoot":"","sources":["../../src/commands/init-helpers.ts"],"names":[],"mappings":"AAuFA,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAYf;AASD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAmCnE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiBpD"}

package/dist/commands/init-helpers.js

@@ -24,6 +24,8 @@ const POST_CHECKOUT_HOOK = `#!/bin/sh
 # post-checkout hook for kibi
 # Parameters: old_ref new_ref branch_flag
 # branch_flag is 1 for branch checkout, 0 for file checkout
+# Refresh branch/worktree assumptions after checkout so advisory plugin state
+# starts from synced KB data instead of stale in-memory cache assumptions.
 
 old_ref=$1
 new_ref=$2
@@ -44,6 +46,7 @@ fi
 const POST_MERGE_HOOK = `#!/bin/sh
 # post-merge hook for kibi
 # Parameter: squash_flag (not used)
+# Refresh KB state after merge so branch-level assumptions remain current.
 
 kibi sync
 `;
@@ -60,7 +63,8 @@ fi
 `;
 const PRE_COMMIT_HOOK = `#!/bin/sh
 # pre-commit hook for kibi
-# Blocks commits if kibi check finds violations
+# Hard enforcement boundary: commits are blocked only here via kibi check.
+# The OpenCode plugin remains advisory and must not replace this gate.
 
 set -e
 kibi check --staged

package/dist/extractors/manifest.d.ts

@@ -27,5 +27,6 @@ export declare class ManifestError extends Error {
     filePath: string;
     constructor(message: string, filePath: string);
 }
+export declare function extractFromManifestString(content: string, filePath: string): ExtractionResult[];
 export declare function extractFromManifest(filePath: string): ExtractionResult[];
 //# sourceMappingURL=manifest.d.ts.map

package/dist/extractors/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/extractors/manifest.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,aAAc,SAAQ,KAAK;IAG7B,QAAQ,EAAE,MAAM;gBADvB,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM;CAK1B;AAwBD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE,CA6FxE"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/extractors/manifest.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,aAAc,SAAQ,KAAK;IAG7B,QAAQ,EAAE,MAAM;gBADvB,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM;CAK1B;AA6GD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,gBAAgB,EAAE,CAmBpB;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAGxE"}

package/dist/extractors/manifest.js

@@ -26,77 +26,79 @@ export class ManifestError extends Error {
         this.name = "ManifestError";
     }
 }
-// implements REQ-007
-export function extractFromManifest(filePath) {
-    try {
-        const content = readFileSync(filePath, "utf8");
-        const manifest = parseYAML(content);
-        if (!manifest.symbols || !Array.isArray(manifest.symbols)) {
-            throw new ManifestError("No symbols array found in manifest", filePath);
-        }
-        return manifest.symbols.map((symbol) => {
-            if (!symbol.title) {
-                throw new ManifestError("Missing required field: title", filePath);
+function extractRelationships(id, symbol) {
+    const relationships = [];
+    if (Array.isArray(symbol.links)) {
+        for (const link of symbol.links) {
+            if (typeof link === "string") {
+                relationships.push({
+                    type: "implements",
+                    from: id,
+                    to: link,
+                });
             }
-            const id = symbol.id || generateId(filePath, symbol.title);
-            const relationships = [];
-            // Extract relationships from links field
-            // Supports both simple strings (treated as implements) and typed objects
-            if (Array.isArray(symbol.links)) {
-                for (const link of symbol.links) {
-                    if (typeof link === "string") {
-                        relationships.push({
-                            type: "implements",
-                            from: id,
-                            to: link,
-                        });
-                    }
-                    else if (link !== null && typeof link === "object") {
-                        const typedLink = link;
-                        if (typeof typedLink.type === "string" &&
-                            typeof typedLink.target === "string") {
-                            relationships.push({
-                                type: typedLink.type,
-                                from: id,
-                                to: typedLink.target,
-                            });
-                        }
-                    }
+            else if (link !== null && typeof link === "object") {
+                const typedLink = link;
+                if (typeof typedLink.type === "string" &&
+                    typeof typedLink.target === "string") {
+                    relationships.push({
+                        type: typedLink.type,
+                        from: id,
+                        to: typedLink.target,
+                    });
                 }
             }
-            // Extract relationships from relationships field
-            if (Array.isArray(symbol.relationships)) {
-                for (const rel of symbol.relationships) {
-                    if (rel &&
-                        typeof rel.type === "string" &&
-                        typeof rel.target === "string") {
-                        relationships.push({
-                            type: rel.type,
-                            from: id,
-                            to: rel.target,
-                        });
-                    }
-                }
+        }
+    }
+    if (Array.isArray(symbol.relationships)) {
+        for (const rel of symbol.relationships) {
+            if (rel &&
+                typeof rel.type === "string" &&
+                typeof rel.target === "string") {
+                relationships.push({
+                    type: rel.type,
+                    from: id,
+                    to: rel.target,
+                });
             }
-            return {
-                entity: {
-                    id,
-                    type: "symbol",
-                    title: symbol.title,
-                    status: symbol.status || "active",
-                    created_at: symbol.created_at || new Date().toISOString(),
-                    updated_at: symbol.updated_at || new Date().toISOString(),
-                    source: filePath,
-                    tags: symbol.tags,
-                    owner: symbol.owner,
-                    priority: symbol.priority,
-                    severity: symbol.severity,
-                    text_ref: symbol.text_ref,
-                },
-                relationships,
-                sourceFile: symbol.sourceFile ?? symbol.source,
-            };
-        });
+        }
+    }
+    return relationships;
+}
+function extractFromParsedManifest(manifest, filePath) {
+    if (!manifest.symbols || !Array.isArray(manifest.symbols)) {
+        throw new ManifestError("No symbols array found in manifest", filePath);
+    }
+    return manifest.symbols.map((symbol) => {
+        if (!symbol.title) {
+            throw new ManifestError("Missing required field: title", filePath);
+        }
+        const id = symbol.id || generateId(filePath, symbol.title);
+        return {
+            entity: {
+                id,
+                type: "symbol",
+                title: symbol.title,
+                status: symbol.status || "active",
+                created_at: symbol.created_at || new Date().toISOString(),
+                updated_at: symbol.updated_at || new Date().toISOString(),
+                source: filePath,
+                tags: symbol.tags,
+                owner: symbol.owner,
+                priority: symbol.priority,
+                severity: symbol.severity,
+                text_ref: symbol.text_ref,
+            },
+            relationships: extractRelationships(id, symbol),
+            sourceFile: symbol.sourceFile ?? symbol.source,
+        };
+    });
+}
+// implements REQ-007
+export function extractFromManifestString(content, filePath) {
+    try {
+        const manifest = parseYAML(content);
+        return extractFromParsedManifest(manifest, filePath);
     }
     catch (error) {
         if (error instanceof ManifestError) {
@@ -108,6 +110,10 @@ export function extractFromManifest(filePath) {
         throw error;
     }
 }
+export function extractFromManifest(filePath) {
+    const content = readFileSync(filePath, "utf8");
+    return extractFromManifestString(content, filePath);
+}
 function generateId(filePath, title) {
     const hash = createHash("sha256");
     hash.update(`${filePath}:${title}`);

package/dist/extractors/markdown.d.ts

@@ -50,6 +50,7 @@ export declare class FrontmatterError extends Error {
     toString(): string;
 }
 export declare function detectEmbeddedEntities(data: Record<string, unknown>, entityType: string): string[];
+export declare function extractFromMarkdownString(content: string, filePath: string): ExtractionResult;
 export declare function extractFromMarkdown(filePath: string): ExtractionResult;
 export declare function inferTypeFromPath(filePath: string): string | null;
 export declare function normalizeDateLike(value: unknown): string | undefined;

package/dist/extractors/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/extractors/markdown.ts"],"names":[],"mappings":"AAmDA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,SAAS,CAAC,EAAE,SAAS,GAAG,gBAAgB,GAAG,aAAa,GAAG,MAAM,CAAC;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;IACtD,UAAU,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC;AAaD,qBAAa,gBAAiB,SAAQ,KAAK;IAOhC,QAAQ,EAAE,MAAM;IANlB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;gBAG5B,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE;QACR,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB;IASM,QAAQ;CAUlB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,CA8CV;AAGD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CA+NtE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASjE;AASD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAQpE"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/extractors/markdown.ts"],"names":[],"mappings":"AAmDA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,SAAS,CAAC,EAAE,SAAS,GAAG,gBAAgB,GAAG,aAAa,GAAG,MAAM,CAAC;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;IACtD,UAAU,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC;AAaD,qBAAa,gBAAiB,SAAQ,KAAK;IAOhC,QAAQ,EAAE,MAAM;IANlB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;gBAG5B,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE;QACR,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB;IASM,QAAQ;CAUlB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,CA8CV;AA6ND,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,gBAAgB,CAElB;AAGD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAatE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASjE;AASD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAQpE"}

package/dist/extractors/markdown.js

@@ -118,14 +118,7 @@ export function detectEmbeddedEntities(data, entityType) {
     return detected;
 }
 // implements REQ-007, REQ-004
-export function extractFromMarkdown(filePath) {
-    let content;
-    try {
-        content = readFileSync(filePath, "utf8");
-    }
-    catch (error) {
-        throw new FrontmatterError(`Failed to read file: ${error instanceof Error ? error.message : String(error)}`, filePath, { classification: "File Read Error" });
-    }
+function extractFromMarkdownContent(content, filePath) {
     try {
         const { data } = matter(content);
         if (content.trim().startsWith("---")) {
@@ -292,6 +285,21 @@ export function extractFromMarkdown(filePath) {
         throw error;
     }
 }
+// implements REQ-007, REQ-004
+export function extractFromMarkdownString(content, filePath) {
+    return extractFromMarkdownContent(content, filePath);
+}
+// implements REQ-007, REQ-004
+export function extractFromMarkdown(filePath) {
+    let content;
+    try {
+        content = readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        throw new FrontmatterError(`Failed to read file: ${error instanceof Error ? error.message : String(error)}`, filePath, { classification: "File Read Error" });
+    }
+    return extractFromMarkdownContent(content, filePath);
+}
 export function inferTypeFromPath(filePath) {
     if (filePath.includes("/requirements/"))
         return "req";

package/dist/prolog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AA4BA,wBAAgB,eAAe,IAAI,MAAM,CAyCxC;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAoCd,YAAY;IAyCpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAuJ1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;YAIZ,YAAY;IAkC1B,OAAO,CAAC,WAAW;IAsGnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,cAAc;IA8BtB,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBjC"}
+{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AA4BA,wBAAgB,eAAe,IAAI,MAAM,CAyCxC;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAsCd,YAAY;IA0CpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAuJ1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;YAIZ,YAAY;IAkC1B,OAAO,CAAC,WAAW;IAsGnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,cAAc;IA8BtB,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBjC"}

package/dist/prolog.js

@@ -88,6 +88,7 @@ export class PrologProcess {
         this.process.stderr.on("data", (chunk) => {
             this.errorBuffer += chunk.toString();
         });
+        this.process.stdin.write("true.\n");
         if (!this.onProcessExit) {
             this.onProcessExit = () => {
                 void this.terminate();
@@ -109,13 +110,14 @@ export class PrologProcess {
             if (this.errorBuffer.includes("ERROR")) {
                 throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
             }
-            // If stdout or stderr shows any output, assume ready.
-            if (this.outputBuffer.length > 0 || this.errorBuffer.length > 0) {
-                break;
+            if (this.outputBuffer.includes("true.")) {
+                this.outputBuffer = "";
+                this.errorBuffer = "";
+                return;
             }
             // brief pause
             // eslint-disable-next-line no-await-in-loop
-            await new Promise((resolve) => setTimeout(resolve, 50));
+            await new Promise((resolve) => setTimeout(resolve, 10));
         }
         // Final sanity check
         if (this.errorBuffer.includes("ERROR")) {

package/dist/public/schemas/entity.d.ts

@@ -46,6 +46,9 @@ declare const entitySchema: {
         text_ref: {
             type: string;
         };
+        sourceFile: {
+            type: string;
+        };
         type: {
             type: string;
             enum: string[];

package/dist/public/schemas/entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAwBA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHjB,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAwBA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHjB,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/public/schemas/entity.js

@@ -55,6 +55,7 @@ const entitySchema = {
         severity: { type: "string" },
         links: { type: "array", items: { type: "string" } },
         text_ref: { type: "string" },
+        sourceFile: { type: "string" },
         type: {
             type: "string",
             enum: [

package/dist/schemas/entity.schema.json

@@ -38,6 +38,7 @@
         "severity": { "type": "string" },
         "links": { "type": "array", "items": { "type": "string" } },
         "text_ref": { "type": "string" },
+        "sourceFile": { "type": "string" },
         "type": {
             "type": "string",
             "enum": [

package/dist/traceability/symbol-extract.d.ts

@@ -1,4 +1,8 @@
 import type { HunkRange, StagedFile } from "./git-staged.js";
+type TraceabilityRelationship = {
+    type: string;
+    to: string;
+};
 export interface ExtractedSymbol {
     id: string;
     name: string;
@@ -10,11 +14,14 @@ export interface ExtractedSymbol {
     };
     hunkRanges: HunkRange[];
     reqLinks: string[];
+    relationships?: TraceabilityRelationship[];
 }
 export interface ManifestLookupEntry {
     id: string;
-    links?: string[];
+    relationships?: TraceabilityRelationship[];
 }
 export type ManifestLookup = Map<string, ManifestLookupEntry>;
+export declare function createManifestLookupSentinelKey(manifestPath: string): string;
 export declare function extractSymbolsFromStagedFile(stagedFile: StagedFile, manifestLookup?: ManifestLookup): ExtractedSymbol[];
+export {};
 //# sourceMappingURL=symbol-extract.d.ts.map

package/dist/traceability/symbol-extract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IAC7D,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AA4D9D,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CAuNnB"}
+{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAM7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IAC7D,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AAyLD,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CA+JnB"}

package/dist/traceability/symbol-extract.js

@@ -1,6 +1,93 @@
 import { createHash } from "node:crypto";
 import { Project, ScriptKind } from "ts-morph";
 import { extractFromManifest } from "../extractors/manifest.js";
+const TRACEABILITY_RELATIONSHIP_TYPES = new Set(["implements", "covered_by"]);
+const REQUIREMENT_ID_PATTERN = /^[A-Z][A-Z0-9\-_]*$/;
+const LOCAL_MANIFEST_NAMES = ["symbols.yaml", "symbols.yml"];
+const MANIFEST_SENTINEL_PREFIX = "__manifest__:";
+export function createManifestLookupSentinelKey(manifestPath) {
+    // implements REQ-008
+    return `${MANIFEST_SENTINEL_PREFIX}${manifestPath}`;
+}
+function getCandidateManifestPaths(filePath) {
+    const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+    if (!dir) {
+        return [];
+    }
+    return LOCAL_MANIFEST_NAMES.map((manifestName) => `${dir}/${manifestName}`);
+}
+function createHashFallbackId(filePath, name) {
+    const h = createHash("sha256");
+    h.update(`${filePath}:${name}`);
+    return h.digest("hex").slice(0, 16);
+}
+function filterTraceabilityRelationships(relationships) {
+    if (!relationships?.length) {
+        return [];
+    }
+    return relationships.filter((relationship) => TRACEABILITY_RELATIONSHIP_TYPES.has(relationship.type));
+}
+function getRequirementLinks(relationships) {
+    return filterTraceabilityRelationships(relationships)
+        .filter((relationship) => relationship.type === "implements" &&
+        REQUIREMENT_ID_PATTERN.test(relationship.to))
+        .map((relationship) => relationship.to);
+}
+function resolveSymbolTraceability(filePath, name, manifestLookup) {
+    if (manifestLookup) {
+        const lookupKey = `${filePath}:${name}`;
+        const entry = manifestLookup.get(lookupKey);
+        if (entry) {
+            return {
+                id: entry.id,
+                relationships: filterTraceabilityRelationships(entry.relationships),
+            };
+        }
+    }
+    const candidateManifestPaths = getCandidateManifestPaths(filePath);
+    if (manifestLookup &&
+        candidateManifestPaths.some((manifestPath) => manifestLookup.has(createManifestLookupSentinelKey(manifestPath)))) {
+        return { id: createHashFallbackId(filePath, name) };
+    }
+    for (const manifestPath of candidateManifestPaths) {
+        try {
+            const ents = extractFromManifest(manifestPath);
+            for (const e of ents) {
+                if (e.entity.title === name) {
+                    return {
+                        id: e.entity.id,
+                        relationships: filterTraceabilityRelationships(e.relationships.map((relationship) => ({
+                            type: relationship.type,
+                            to: relationship.to,
+                        }))),
+                    };
+                }
+            }
+        }
+        catch {
+            // ignore - no local manifest or parse error
+        }
+    }
+    return { id: createHashFallbackId(filePath, name) };
+}
+function buildSymbolResult(stagedFile, name, kind, span, inlineReqLinks, manifestLookup) {
+    const { id, relationships } = resolveSymbolTraceability(stagedFile.path, name, manifestLookup);
+    const manifestReqLinks = getRequirementLinks(relationships);
+    const mergedReqLinks = inlineReqLinks.length > 0 ? inlineReqLinks : manifestReqLinks;
+    return {
+        id,
+        name,
+        kind,
+        location: {
+            file: stagedFile.path,
+            startLine: span.startLine,
+            endLine: span.endLine,
+        },
+        hunkRanges: intersectingHunks(span.startLine, span.endLine, stagedFile.hunkRanges),
+        reqLinks: mergedReqLinks,
+        relationships,
+    };
+}
 // Simple in-memory cache keyed by blob sha with 30s TTL
 const sourceFileCache = new Map();
 const CACHE_TTL_MS = 30 * 1000;
@@ -94,21 +181,7 @@ stagedFile, manifestLookup) {
                 .getJsDocs()
                 .map((d) => d.getFullText())
                 .join("\n")}`);
-            const { id, reqLinks: manifestLinks } = resolveSymbolId(stagedFile.path, name, manifestLookup);
-            // Merge manifest links with inline directive links (manifest links as fallback)
-            const mergedReqLinks = reqLinks.length > 0 ? reqLinks : (manifestLinks ?? []);
-            results.push({
-                id,
-                name,
-                kind: "function",
-                location: {
-                    file: stagedFile.path,
-                    startLine: span.startLine,
-                    endLine: span.endLine,
-                },
-                hunkRanges: intersectingHunks(span.startLine, span.endLine, stagedFile.hunkRanges),
-                reqLinks: mergedReqLinks,
-            });
+            results.push(buildSymbolResult(stagedFile, name, "function", span, reqLinks, manifestLookup));
         }
         catch {
             // skip: individual declaration extraction may fail on malformed AST nodes
@@ -127,21 +200,7 @@ stagedFile, manifestLookup) {
                 .getJsDocs()
                 .map((d) => d.getFullText())
                 .join("\n")}`);
-            const { id, reqLinks: manifestLinks } = resolveSymbolId(stagedFile.path, name, manifestLookup);
-            // Merge manifest links with inline directive links (manifest links as fallback)
-            const mergedReqLinks = reqLinks.length > 0 ? reqLinks : (manifestLinks ?? []);
-            results.push({
-                id,
-                name,
-                kind: "class",
-                location: {
-                    file: stagedFile.path,
-                    startLine: span.startLine,
-                    endLine: span.endLine,
-                },
-                hunkRanges: intersectingHunks(span.startLine, span.endLine, stagedFile.hunkRanges),
-                reqLinks: mergedReqLinks,
-            });
+            results.push(buildSymbolResult(stagedFile, name, "class", span, reqLinks, manifestLookup));
         }
         catch {
             // skip: individual declaration extraction may fail on malformed AST nodes
@@ -157,21 +216,7 @@ stagedFile, manifestLookup) {
             const end = en.getEnd();
             const span = getSpan(start, end);
             const reqLinks = parseReqDirectives(en.getText());
-            const { id, reqLinks: manifestLinks } = resolveSymbolId(stagedFile.path, name, manifestLookup);
-            // Merge manifest links with inline directive links (manifest links as fallback)
-            const mergedReqLinks = reqLinks.length > 0 ? reqLinks : (manifestLinks ?? []);
-            results.push({
-                id,
-                name,
-                kind: "enum",
-                location: {
-                    file: stagedFile.path,
-                    startLine: span.startLine,
-                    endLine: span.endLine,
-                },
-                hunkRanges: intersectingHunks(span.startLine, span.endLine, stagedFile.hunkRanges),
-                reqLinks: mergedReqLinks,
-            });
+            results.push(buildSymbolResult(stagedFile, name, "enum", span, reqLinks, manifestLookup));
         }
         catch {
             // skip: individual declaration extraction may fail on malformed AST nodes
@@ -188,21 +233,7 @@ stagedFile, manifestLookup) {
                 const end = decl.getEnd();
                 const span = getSpan(start, end);
                 const reqLinks = parseReqDirectives(decl.getText());
-                const { id, reqLinks: manifestLinks } = resolveSymbolId(stagedFile.path, name, manifestLookup);
-                // Merge manifest links with inline directive links (manifest links as fallback)
-                const mergedReqLinks = reqLinks.length > 0 ? reqLinks : (manifestLinks ?? []);
-                results.push({
-                    id,
-                    name,
-                    kind: "variable",
-                    location: {
-                        file: stagedFile.path,
-                        startLine: span.startLine,
-                        endLine: span.endLine,
-                    },
-                    hunkRanges: intersectingHunks(span.startLine, span.endLine, stagedFile.hunkRanges),
-                    reqLinks: mergedReqLinks,
-                });
+                results.push(buildSymbolResult(stagedFile, name, "variable", span, reqLinks, manifestLookup));
             }
             catch {
                 // skip: individual declaration extraction may fail on malformed AST nodes
@@ -225,40 +256,3 @@ function intersectingHunks(startLine, endLine, hunks) {
     }
     return out;
 }
-function resolveSymbolId(filePath, name, manifestLookup) {
-    // First, check the provided manifest lookup if available
-    if (manifestLookup) {
-        // Normalize the source file path for consistent lookup
-        const normalizedSource = filePath;
-        const lookupKey = `${normalizedSource}:${name}`;
-        const entry = manifestLookup.get(lookupKey);
-        if (entry) {
-            return { id: entry.id, reqLinks: entry.links };
-        }
-    }
-    // Fallback: attempt to read manifest entries from a local symbols.yaml (best-effort)
-    try {
-        // Try to find a symbols.yaml in the same directory as the file
-        const dir = filePath.substring(0, filePath.lastIndexOf("/"));
-        if (dir) {
-            const manifestPath = `${dir}/symbols.yaml`;
-            const ents = extractFromManifest(manifestPath);
-            for (const e of ents) {
-                if (e.entity.title === name) {
-                    // Extract requirement links from relationships
-                    const reqLinks = e.relationships
-                        .filter((r) => r.type === "implements" && r.to.match(/^[A-Z][A-Z0-9\-_]*$/))
-                        .map((r) => r.to);
-                    return { id: e.entity.id, reqLinks };
-                }
-            }
-        }
-    }
-    catch {
-        // ignore - no local manifest or parse error
-    }
-    // Final fallback: deterministic id: sha(file:path:name)
-    const h = createHash("sha256");
-    h.update(`${filePath}:${name}`);
-    return { id: h.digest("hex").slice(0, 16) };
-}

package/dist/traceability/temp-kb.d.ts

@@ -1,3 +1,4 @@
+import type { ExtractionResult } from "../extractors/markdown.js";
 import { PrologProcess } from "../prolog.js";
 import type { ExtractedSymbol } from "./symbol-extract";
 export interface TempKbContext {
@@ -8,6 +9,7 @@ export interface TempKbContext {
 }
 declare function consultOverlay(ctx: TempKbContext): Promise<void>;
 export { consultOverlay };
+export declare function projectStagedEntities(prolog: PrologProcess, results: ExtractionResult[]): Promise<void>;
 export declare function createTempKb(baseKbPath: string): Promise<TempKbContext>;
 export declare function createOverlayFacts(symbols: ExtractedSymbol[]): string;
 export declare function cleanupTempKb(tempDir: string): Promise<void>;

package/dist/traceability/temp-kb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"temp-kb.d.ts","sourceRoot":"","sources":["../../src/traceability/temp-kb.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB;AAmDD,iBAAe,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAe/D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA2C7E;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBrE;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE"}
+{"version":3,"file":"temp-kb.d.ts","sourceRoot":"","sources":["../../src/traceability/temp-kb.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB;AA4ID,iBAAe,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAG1B,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA2C7E;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBrE;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE"}

package/dist/traceability/temp-kb.js

@@ -3,9 +3,28 @@ import { cp, mkdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { PrologProcess } from "../prolog.js";
+import { toPrologAtom, toPrologString } from "../prolog/codec.js";
 const prologByTempDir = new Map();
 const cleanupByTempDir = new Map();
 const cleanedTempDirs = new Set();
+const FACT_ATOM_FIELDS = new Set([
+    "fact_kind",
+    "operator",
+    "value_type",
+    "polarity",
+]);
+const FACT_STRING_FIELDS = new Set([
+    "subject_key",
+    "property_key",
+    "value_string",
+    "unit",
+    "scope",
+    "valid_from",
+    "valid_to",
+    "canonical_key",
+]);
+const FACT_NUMBER_FIELDS = new Set(["value_int", "value_number"]);
+const FACT_BOOLEAN_FIELDS = new Set(["value_bool", "closed_world"]);
 function isTraceEnabled() {
     return Boolean(process.env.KIBI_TRACE || process.env.KIBI_DEBUG);
 }
@@ -18,6 +37,66 @@ function trace(message) {
 function escapePrologAtom(value) {
     return `'${value.replace(/'/g, "''")}'`;
 }
+function serializeTypedFactFields(entity) {
+    const fields = [];
+    const entityRecord = entity;
+    for (const field of FACT_STRING_FIELDS) {
+        const value = entityRecord[field];
+        if (value !== undefined && value !== null) {
+            fields.push(`${field}=${toPrologString(String(value))}`);
+        }
+    }
+    for (const field of FACT_ATOM_FIELDS) {
+        const value = entityRecord[field];
+        if (value !== undefined && value !== null) {
+            fields.push(`${field}=${toPrologAtom(String(value))}`);
+        }
+    }
+    for (const field of FACT_NUMBER_FIELDS) {
+        const value = entityRecord[field];
+        if (value !== undefined && value !== null && typeof value === "number") {
+            if (field === "value_int" && !Number.isInteger(value)) {
+                continue;
+            }
+            fields.push(`${field}=${value}`);
+        }
+    }
+    for (const field of FACT_BOOLEAN_FIELDS) {
+        const value = entityRecord[field];
+        if (value !== undefined && value !== null && typeof value === "boolean") {
+            fields.push(`${field}=${value}`);
+        }
+    }
+    return fields;
+}
+function buildEntityAssertionGoal(entity) {
+    const props = [
+        `id=${toPrologAtom(entity.id)}`,
+        `title=${toPrologString(entity.title)}`,
+        `status=${toPrologAtom(entity.status)}`,
+        `created_at=${toPrologString(entity.created_at)}`,
+        `updated_at=${toPrologString(entity.updated_at)}`,
+        `source=${toPrologString(entity.source)}`,
+    ];
+    if (entity.tags && entity.tags.length > 0) {
+        props.push(`tags=[${entity.tags.map(toPrologAtom).join(",")}]`);
+    }
+    if (entity.owner)
+        props.push(`owner=${toPrologAtom(entity.owner)}`);
+    if (entity.priority)
+        props.push(`priority=${toPrologAtom(entity.priority)}`);
+    if (entity.severity)
+        props.push(`severity=${toPrologAtom(entity.severity)}`);
+    if (entity.text_ref)
+        props.push(`text_ref=${toPrologString(entity.text_ref)}`);
+    if (entity.type === "fact") {
+        props.push(...serializeTypedFactFields(entity));
+    }
+    return `kb_assert_entity(${entity.type}, [${props.join(", ")}])`;
+}
+function buildRelationshipAssertionGoal(relationship) {
+    return `kb_assert_relationship(${toPrologAtom(relationship.type)}, ${toPrologAtom(relationship.from)}, ${toPrologAtom(relationship.to)}, [])`;
+}
 function createCleanupHandler(tempDir) {
     let inProgress = false;
     return () => {
@@ -49,12 +128,34 @@ async function consultOverlay(ctx) {
     }
     const consultResult = await prolog.query([
         `consult(${escapePrologAtom(ctx.overlayPath)})`,
+        "kb_save",
     ]);
     if (!consultResult.success) {
         throw new Error(`Failed to consult overlay facts ${ctx.overlayPath}: ${consultResult.error || "unknown error"}`);
     }
 }
 export { consultOverlay };
+// implements REQ-014
+export async function projectStagedEntities(prolog, results) {
+    for (const { entity } of results) {
+        const retractResult = await prolog.query(`kb_retract_entity(${toPrologAtom(entity.id)})`);
+        if (!retractResult.success) {
+            throw new Error(`Failed to retract staged entity ${entity.id}: ${retractResult.error || "unknown error"}`);
+        }
+        const assertEntityResult = await prolog.query(buildEntityAssertionGoal(entity));
+        if (!assertEntityResult.success) {
+            throw new Error(`Failed to assert staged entity ${entity.id}: ${assertEntityResult.error || "unknown error"}`);
+        }
+    }
+    for (const { relationships } of results) {
+        for (const relationship of relationships) {
+            const assertRelationshipResult = await prolog.query(buildRelationshipAssertionGoal(relationship));
+            if (!assertRelationshipResult.success) {
+                throw new Error(`Failed to assert staged relationship ${relationship.type} ${relationship.from} -> ${relationship.to}: ${assertRelationshipResult.error || "unknown error"}`);
+            }
+        }
+    }
+}
 export async function createTempKb(baseKbPath) {
     if (!existsSync(baseKbPath)) {
         throw new Error(`Base KB path does not exist: ${baseKbPath}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -76,7 +76,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.3.0",
+    "kibi-core": "^0.4.1",
     "ts-morph": "^23.0.0"
   },
   "devDependencies": {

package/src/public/schemas/entity.ts

@@ -62,6 +62,7 @@ const entitySchema = {
     severity: { type: "string" },
     links: { type: "array", items: { type: "string" } },
     text_ref: { type: "string" },
+    sourceFile: { type: "string" },
     type: {
       type: "string",
       enum: [

package/src/schemas/entity.schema.json

@@ -38,6 +38,7 @@
     "severity": { "type": "string" },
     "links": { "type": "array", "items": { "type": "string" } },
     "text_ref": { "type": "string" },
+    "sourceFile": { "type": "string" },
     "type": {
       "type": "string",
       "enum": [