kibi-runtime 2.10.0 → 2.11.0

package/dist/engine-daemon.js

@@ -4,7 +4,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../cli/src/engine-daemon.ts
 import { writeFileSync as writeFileSync3 } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // ../cli/src/engine.ts
@@ -17,7 +17,7 @@ import {
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync2,
   openSync as openSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync2,
   realpathSync as realpathSync3,
   renameSync,
@@ -28,7 +28,7 @@ import {
 } from "node:fs";
 import * as net from "node:net";
 import * as os from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 
 // ../cli/src/engine-limits.ts
@@ -85,6 +85,40 @@ function queryLimitMessage(hit) {
   return `${QUERY_LIMIT_EXCEEDED_CODE}: read stopped at its ${budget} before computing an answer. Narrow the query or raise the limit.`;
 }
 
+// ../cli/src/package-versions.ts
+import { readFileSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire2(import.meta.url);
+var moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+function manifestVersion(manifestPath, expectedName) {
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return manifest.name === expectedName && typeof manifest.version === "string" ? manifest.version : undefined;
+  } catch {
+    return;
+  }
+}
+function cliVersion() {
+  if (true)
+    return "2.13.0";
+  return manifestVersion(path.join(moduleDirectory, "..", "package.json"), "kibi-cli") ?? "unknown";
+}
+function coreVersion() {
+  try {
+    const resolved = manifestVersion(require2.resolve("kibi-core/package.json"), "kibi-core");
+    if (resolved)
+      return resolved;
+  } catch {}
+  return manifestVersion(path.join(moduleDirectory, "..", "..", "core", "package.json"), "kibi-core") ?? "unknown";
+}
+var KIBI_BUILT_PACKAGE_VERSIONS = `kibi-cli@${cliVersion()},kibi-core@${coreVersion()}`;
+function kibiPackageVersions() {
+  const override = process.env.KIBI_PACKAGE_VERSIONS;
+  return override !== undefined && override.length > 0 ? override : KIBI_BUILT_PACKAGE_VERSIONS;
+}
+
 // ../cli/src/performance-trace.ts
 import { constants } from "node:fs";
 import {
@@ -96,7 +130,7 @@ import {
   statSync,
   writeSync
 } from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 var KIBI_PERF_TRACE_DIR_ENV = "KIBI_PERF_TRACE_DIR";
 var KIBI_PERF_TIMINGS_ENV = "KIBI_PERF_TIMINGS";
 var KIBI_PERF_TRACE_MAX_EVENTS = 5000;
@@ -105,14 +139,14 @@ var states = new Map;
 var MAX_DURATION_MS = 60000;
 var TRACE_LIMIT_RESERVE_BYTES = 96;
 function isWithin(parent, candidate) {
-  const relative = path.relative(parent, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  const relative = path2.relative(parent, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path2.sep}`) && !path2.isAbsolute(relative);
 }
 function privateTraceFile() {
   if (process.env[KIBI_PERF_TIMINGS_ENV] !== "1")
     return null;
   const configuredDirectory = process.env[KIBI_PERF_TRACE_DIR_ENV];
-  if (!configuredDirectory || !path.isAbsolute(configuredDirectory))
+  if (!configuredDirectory || !path2.isAbsolute(configuredDirectory))
     return null;
   try {
     const directoryInfo = lstatSync(configuredDirectory);
@@ -120,7 +154,7 @@ function privateTraceFile() {
       return null;
     }
     const directory = realpathSync(configuredDirectory);
-    if (path.resolve(configuredDirectory) !== directory)
+    if (path2.resolve(configuredDirectory) !== directory)
       return null;
     const directoryStats = statSync(directory);
     if (typeof process.getuid !== "function" || directoryStats.uid !== process.getuid()) {
@@ -132,7 +166,7 @@ function privateTraceFile() {
     const currentDirectory = realpathSync(process.cwd());
     if (isWithin(currentDirectory, directory))
       return null;
-    const file = path.join(directory, `kibi-performance-${process.pid}.jsonl`);
+    const file = path2.join(directory, `kibi-performance-${process.pid}.jsonl`);
     let state = states.get(file);
     if (!state) {
       if (existsSync(file))
@@ -210,10 +244,10 @@ function writePerformanceTraceEvent(event) {
 // ../cli/src/prolog.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import path3 from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+import path4 from "node:path";
 import { performance } from "node:perf_hooks";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../cli/src/env.ts
 function getEnvValue(key) {
@@ -568,10 +602,10 @@ import {
   constants as constants2,
   accessSync,
   existsSync as existsSync2,
-  readFileSync,
+  readFileSync as readFileSync2,
   statSync as statSync2
 } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 import {
   BUNDLED_BINARY_PATH,
   MANIFEST_FILE,
@@ -666,8 +700,8 @@ function inspectBundle(deps) {
   const packageDir = deps.locatePackage(packageName);
   if (packageDir === undefined)
     return { kind: "missing", key, packageName };
-  const manifestPath = path2.join(packageDir, MANIFEST_FILE);
-  const binary = path2.join(packageDir, BUNDLED_BINARY_PATH);
+  const manifestPath = path3.join(packageDir, MANIFEST_FILE);
+  const binary = path3.join(packageDir, BUNDLED_BINARY_PATH);
   if (!existsSync2(manifestPath)) {
     if (!existsSync2(binary))
       return { kind: "empty", key, packageName };
@@ -687,12 +721,12 @@ function inspectBundle(deps) {
   let manifest;
   let packageJson;
   try {
-    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
   } catch (error) {
     return corrupt(`${MANIFEST_FILE} is not valid JSON (${error instanceof Error ? error.message : String(error)})`);
   }
   try {
-    packageJson = JSON.parse(readFileSync(path2.join(packageDir, "package.json"), "utf8"));
+    packageJson = JSON.parse(readFileSync2(path3.join(packageDir, "package.json"), "utf8"));
   } catch (error) {
     return corrupt(`package.json is unreadable (${error instanceof Error ? error.message : String(error)})`);
   }
@@ -715,7 +749,7 @@ function inspectBundle(deps) {
   if (actual !== checked.binarySha256) {
     return corrupt(`${BUNDLED_BINARY_PATH} SHA-256 ${actual} does not match the manifest (${checked.binarySha256})`);
   }
-  const home = path2.join(packageDir, checked.home);
+  const home = path3.join(packageDir, checked.home);
   let homeIsDirectory = false;
   try {
     homeIsDirectory = statSync2(home).isDirectory();
@@ -757,10 +791,10 @@ function probeVersion(bin, deps) {
   return { kind: "ok", version: parsed.version };
 }
 function findOnPath(env, deps) {
-  for (const directory of (env.PATH ?? "").split(path2.delimiter)) {
-    if (directory === "" || !path2.isAbsolute(directory))
+  for (const directory of (env.PATH ?? "").split(path3.delimiter)) {
+    if (directory === "" || !path3.isAbsolute(directory))
       continue;
-    const candidate = path2.join(directory, "swipl");
+    const candidate = path3.join(directory, "swipl");
     if (!isExecutableFile(candidate))
       continue;
     const probe = probeVersion(candidate, deps);
@@ -783,7 +817,7 @@ function resolveFromEnv(override, deps) {
   });
   const packageName = key === undefined ? undefined : PLATFORM_PACKAGES[key].package;
   const invalid = (detail) => new SwiplResolutionError("swipl_env_invalid", `KIBI_SWIPL=${override} ${detail}. Set KIBI_SWIPL to the absolute path of a SWI-Prolog ${MINIMUM_SWIPL_MAJOR}.0+ executable, to "system" to use swipl from PATH, or unset it to use the bundled runtime.`, platform, packageName);
-  if (!path2.isAbsolute(override))
+  if (!path3.isAbsolute(override))
     return fail(invalid("is not an absolute path"));
   if (!isExecutableFile(override)) {
     return fail(invalid("is not an executable file"));
@@ -891,24 +925,11 @@ function swiplChildEnv(resolved) {
 }
 
 // ../cli/src/prolog.ts
-var importMetaDir = path3.dirname(fileURLToPath(import.meta.url));
+var importMetaDir = path4.dirname(fileURLToPath2(import.meta.url));
 var DEFAULT_PROLOG_OUTPUT_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 var PROLOG_OUTPUT_OVERFLOW_ERROR = "Query exceeded bounded Prolog output capacity (ENOBUFS); narrow the operation or reduce stored entity size";
 var INTERACTIVE_QUERY_FRAME_END = "__KIBI_QUERY_FRAME_END__";
-var require2 = createRequire2(import.meta.url);
-function packageVersion(packagePath) {
-  try {
-    const packageJson = require2(packagePath);
-    return typeof packageJson.version === "string" ? packageJson.version : "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-var KIBI_PACKAGE_VERSIONS = [
-  `kibi-cli@${packageVersion(path3.join(importMetaDir, "..", "package.json"))}`,
-  `kibi-core@${packageVersion(path3.join(importMetaDir, "..", "..", "core", "package.json"))}`,
-  `kibi-mcp@${packageVersion(path3.join(importMetaDir, "..", "..", "mcp", "package.json"))}`
-].join(",");
+var require3 = createRequire3(import.meta.url);
 function resolveKbPlPath() {
   const overrideKbPath = getKbPlPathOverride();
   if (overrideKbPath) {
@@ -916,20 +937,20 @@ function resolveKbPlPath() {
   }
   try {
     try {
-      return require2.resolve("kibi-core/src/kb.pl");
+      return require3.resolve("kibi-core/src/kb.pl");
     } catch {
-      const coreMain = require2.resolve("kibi-core");
-      const coreDir = path3.dirname(coreMain);
-      return path3.join(coreDir, "src", "kb.pl");
+      const coreMain = require3.resolve("kibi-core");
+      const coreDir = path4.dirname(coreMain);
+      return path4.join(coreDir, "src", "kb.pl");
     }
   } catch {}
   let currentDir = importMetaDir;
-  while (currentDir !== path3.dirname(currentDir)) {
-    const candidate = path3.join(currentDir, "packages", "core", "src", "kb.pl");
+  while (currentDir !== path4.dirname(currentDir)) {
+    const candidate = path4.join(currentDir, "packages", "core", "src", "kb.pl");
     if (existsSync3(candidate)) {
       return candidate;
     }
-    currentDir = path3.dirname(currentDir);
+    currentDir = path4.dirname(currentDir);
   }
   throw new Error("Unable to resolve kb.pl. Expected kibi-core to be installed (node_modules) " + "or to be running inside the monorepo checkout.");
 }
@@ -1021,7 +1042,7 @@ class PrologProcess {
         ...launch.env,
         KIBI_RUNTIME_NAME: process.versions.bun !== undefined ? "bun" : "node",
         KIBI_RUNTIME_VERSION: process.versions.bun ?? process.versions.node ?? "unknown",
-        KIBI_PACKAGE_VERSIONS: process.env.KIBI_PACKAGE_VERSIONS ?? KIBI_PACKAGE_VERSIONS
+        KIBI_PACKAGE_VERSIONS: kibiPackageVersions()
       }
     });
     this.clearQueryBuffers();
@@ -1142,7 +1163,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
             console.error(`[prolog debug] timeout: ${msg}`);
             const runtime = this.errorBuffer.split(`
 `).find((line) => line.includes("__KIBI_RUNTIME__"));
-            console.error(`[prolog debug] runtime=${runtime ?? "unknown"} packages=${process.env.KIBI_PACKAGE_VERSIONS ?? KIBI_PACKAGE_VERSIONS}`);
+            console.error(`[prolog debug] runtime=${runtime ?? "unknown"} packages=${kibiPackageVersions()}`);
           }
           settle();
           this.terminationReason = `query timeout: ${goalLabel}`;
@@ -1341,7 +1362,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     ].join(", ");
     const runtimeName = process.versions.bun !== undefined ? "bun" : "node";
     const runtimeVersion = process.versions.bun ?? process.versions.node ?? "unknown";
-    const packageVersions = process.env.KIBI_PACKAGE_VERSIONS ?? KIBI_PACKAGE_VERSIONS;
+    const packageVersions = kibiPackageVersions();
     let child;
     try {
       const launch = this.launchTarget();
@@ -1720,7 +1741,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
 
 // ../cli/src/prolog/store-lock.ts
 import { existsSync as existsSync4, rmSync } from "node:fs";
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { dirname, join } from "node:path";
 var cachedBootId;
 function currentBootId() {
@@ -1731,7 +1752,7 @@ function currentBootId() {
     return cachedBootId;
   }
   try {
-    const raw = readFileSync2("/proc/sys/kernel/random/boot_id", "utf8");
+    const raw = readFileSync3("/proc/sys/kernel/random/boot_id", "utf8");
     cachedBootId = raw.trim();
   } catch {
     cachedBootId = null;
@@ -1824,31 +1845,31 @@ import {
   execFileSync as rawExecFileSync,
   execSync as rawExecSync
 } from "node:child_process";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 
 // ../cli/src/utils/branch-store-locator.ts
 import { createHash } from "node:crypto";
 import {
   existsSync as existsSync5,
   mkdirSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   readdirSync,
   statSync as statSync3,
   writeFileSync
 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 var BRANCH_STORE_MANIFEST_VERSION = 1;
 function branchStoreKey(branch) {
   return createHash("sha256").update(branch, "utf8").digest("hex");
 }
 function branchStoresRoot(workspaceRoot) {
-  return path4.join(path4.resolve(workspaceRoot), ".kb", "branches");
+  return path5.join(path5.resolve(workspaceRoot), ".kb", "branches");
 }
 function branchStorePath(workspaceRoot, branch) {
-  return path4.join(branchStoresRoot(workspaceRoot), branchStoreKey(branch));
+  return path5.join(branchStoresRoot(workspaceRoot), branchStoreKey(branch));
 }
 function branchStoreManifestPath(storePath) {
-  return path4.join(storePath, "branch.json");
+  return path5.join(storePath, "branch.json");
 }
 function expectedBranchStoreManifest(branch) {
   return {
@@ -1862,7 +1883,7 @@ function readBranchStoreManifest(storePath) {
   if (!existsSync5(manifestPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync3(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync4(manifestPath, "utf8"));
     if (parsed.version !== BRANCH_STORE_MANIFEST_VERSION || typeof parsed.branch !== "string" || typeof parsed.key !== "string") {
       return null;
     }
@@ -1878,7 +1899,7 @@ function readBranchStoreManifest(storePath) {
 function branchStoreManifestMatches(storePath, branch) {
   const manifest = readBranchStoreManifest(storePath);
   const expected = expectedBranchStoreManifest(branch);
-  return manifest !== null && manifest.version === expected.version && manifest.branch === expected.branch && manifest.key === expected.key && path4.basename(storePath) === expected.key;
+  return manifest !== null && manifest.version === expected.version && manifest.branch === expected.branch && manifest.key === expected.key && path5.basename(storePath) === expected.key;
 }
 function ensureBranchStoreManifest(workspaceRoot, branch) {
   const storePath = branchStorePath(workspaceRoot, branch);
@@ -1923,7 +1944,7 @@ function isValidBranchName(name) {
     const codePoint = character.codePointAt(0) ?? 0;
     return codePoint <= 32 || codePoint === 127;
   });
-  if (name.includes("..") || path5.isAbsolute(name) || name.startsWith("/")) {
+  if (name.includes("..") || path6.isAbsolute(name) || name.startsWith("/")) {
     return false;
   }
   if (name.includes("//") || name.endsWith("/") || name.endsWith(".") || name.includes("\\") || name.startsWith("-") || name.includes("@{") || name.includes("..") || hasControlCharacter || /[~^:?*\[\]]/.test(name)) {
@@ -1946,13 +1967,13 @@ function isValidBranchName(name) {
 
 // ../cli/src/utils/canonical-path.ts
 import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 function canonicalFilesystemPath(candidate) {
-  let existing = path6.resolve(candidate);
+  let existing = path7.resolve(candidate);
   const missing = [];
   for (;; ) {
     try {
-      return path6.resolve(realpathSync2.native(existing), ...missing);
+      return path7.resolve(realpathSync2.native(existing), ...missing);
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -1965,10 +1986,10 @@ function canonicalFilesystemPath(candidate) {
       }
       if (entry !== undefined)
         throw error;
-      const parent = path6.dirname(existing);
+      const parent = path7.dirname(existing);
       if (parent === existing)
         throw error;
-      missing.unshift(path6.basename(existing));
+      missing.unshift(path7.basename(existing));
       existing = parent;
     }
   }
@@ -1983,7 +2004,10 @@ var READ_LIMITED_METHODS = new Set([
 ]);
 var ENGINE_PROTOCOL_VERSION = 1;
 var ENGINE_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
-var ENGINE_PACKAGE_VERSIONS = process.env.KIBI_PACKAGE_VERSIONS ?? "unknown";
+function enginePackageVersions() {
+  return kibiPackageVersions();
+}
+var ENGINE_PACKAGE_VERSIONS = kibiPackageVersions();
 function engineSwiplIdentity() {
   return swiplIdentity(resolveSwipl());
 }
@@ -1997,16 +2021,16 @@ function requestEngineSignalShutdown(shutdown) {
   };
 }
 function readJournalGeneration(branchPath) {
-  const currentPath = path7.join(branchPath, "CURRENT");
+  const currentPath = path8.join(branchPath, "CURRENT");
   if (!existsSync6(currentPath))
     return "";
-  return readFileSync4(currentPath, "utf8").trim();
+  return readFileSync5(currentPath, "utf8").trim();
 }
 function readEngineAttachmentIdentity(branchPath) {
   if (!existsSync6(branchPath))
     return null;
   const stats = statSync4(branchPath);
-  let resolved = path7.resolve(branchPath);
+  let resolved = path8.resolve(branchPath);
   try {
     resolved = realpathSync3(branchPath);
   } catch {}
@@ -2140,15 +2164,15 @@ function parseFrames(buffer, onFrame) {
   return buffer.subarray(cursor);
 }
 function runtimeDirectory() {
-  const configured = process.env.KIBI_RUNTIME_DIR ?? process.env.XDG_RUNTIME_DIR ?? path7.join(os.tmpdir(), "kibi-runtime");
+  const configured = process.env.KIBI_RUNTIME_DIR ?? process.env.XDG_RUNTIME_DIR ?? path8.join(os.tmpdir(), "kibi-runtime");
   if (process.platform === "win32") {
     for (const candidate of [
       configured,
-      path7.join(os.tmpdir(), "kibi-runtime")
+      path8.join(os.tmpdir(), "kibi-runtime")
     ]) {
       try {
         mkdirSync2(candidate, { recursive: true, mode: 448 });
-        const probe = path7.join(candidate, `.kibi-write-${process.pid}`);
+        const probe = path8.join(candidate, `.kibi-write-${process.pid}`);
         writeFileSync2(probe, "", { mode: 384 });
         unlinkSync(probe);
         return candidate;
@@ -2163,12 +2187,12 @@ function runtimeDirectory() {
   try {
     configuredIdentity = canonicalFilesystemPath(configured);
   } catch {
-    configuredIdentity = path7.resolve(configured);
+    configuredIdentity = path8.resolve(configured);
   }
   const configuredKey = createHash2("sha256").update(configuredIdentity).digest("hex").slice(0, 32);
   const candidates = [
     configured,
-    path7.join("/tmp", `kb-${euid}-${configuredKey}`)
+    path8.join("/tmp", `kb-${euid}-${configuredKey}`)
   ];
   const maximumBytes = process.platform === "linux" ? 107 : 103;
   const socketName = `kibi-${"0".repeat(32)}.sock`;
@@ -2186,9 +2210,9 @@ function runtimeDirectory() {
       if (!directory.isDirectory() || directory.uid !== euid || (directory.mode & 63) !== 0)
         continue;
       const canonical = canonicalFilesystemPath(candidate);
-      if (Buffer.byteLength(path7.join(canonical, socketName), "utf8") > maximumBytes)
+      if (Buffer.byteLength(path8.join(canonical, socketName), "utf8") > maximumBytes)
         continue;
-      const probe = path7.join(canonical, `.kibi-write-${randomUUID()}`);
+      const probe = path8.join(canonical, `.kibi-write-${randomUUID()}`);
       writeFileSync2(probe, "", { mode: 384, flag: "wx" });
       unlinkSync(probe);
       return canonical;
@@ -2209,7 +2233,7 @@ function fsyncPath(filePath) {
   }
 }
 function fsyncJournaledBranchStore(branchPath) {
-  const rdfRoot = path7.join(branchPath, "rdf");
+  const rdfRoot = path8.join(branchPath, "rdf");
   const directories = [];
   const pending = existsSync6(rdfRoot) ? [rdfRoot] : [];
   while (pending.length > 0) {
@@ -2218,7 +2242,7 @@ function fsyncJournaledBranchStore(branchPath) {
       break;
     directories.push(directory);
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
-      const entryPath = path7.join(directory, entry.name);
+      const entryPath = path8.join(directory, entry.name);
       if (entry.isDirectory())
         pending.push(entryPath);
       else if (entry.isFile() && entry.name !== "lock")
@@ -2226,7 +2250,7 @@ function fsyncJournaledBranchStore(branchPath) {
     }
   }
   for (const metadata of ["CURRENT", "storage.json", "kb.rdf"]) {
-    fsyncPath(path7.join(branchPath, metadata));
+    fsyncPath(path8.join(branchPath, metadata));
   }
   if (process.platform !== "win32") {
     for (const directory of directories.reverse())
@@ -2240,22 +2264,22 @@ function engineSocketPath(workspaceRoot, branch) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\kibi-${key}`;
   }
-  return path7.join(runtimeDirectory(), `kibi-${key}.sock`);
+  return path8.join(runtimeDirectory(), `kibi-${key}.sock`);
 }
 function enginePidPath(workspaceRoot, branch) {
   const socket = engineSocketPath(workspaceRoot, branch);
   if (process.platform === "win32") {
-    return path7.join(runtimeDirectory(), `kibi-${createHash2("sha256").update(`${path7.resolve(workspaceRoot)}\x00${branch}`).digest("hex")}.pid`);
+    return path8.join(runtimeDirectory(), `kibi-${createHash2("sha256").update(`${path8.resolve(workspaceRoot)}\x00${branch}`).digest("hex")}.pid`);
   }
   return `${socket}.pid`;
 }
 function recoverStaleJournalLock(branchPath) {
-  const lockPath = path7.join(branchPath, "rdf", "lock");
+  const lockPath = path8.join(branchPath, "rdf", "lock");
   if (!existsSync6(lockPath))
     return;
   let contents = "";
   try {
-    contents = readFileSync4(lockPath, "utf8");
+    contents = readFileSync5(lockPath, "utf8");
   } catch {
     return;
   }
@@ -2303,12 +2327,12 @@ function connectSocket(socketPath, timeoutMs) {
 }
 async function ensureJournaledBranchStoreAsync(branchPath) {
   mkdirSync2(branchPath, { recursive: true });
-  const markerPath = path7.join(branchPath, "storage.json");
-  const marker = existsSync6(markerPath) ? readFileSync4(markerPath, "utf8") : "";
+  const markerPath = path8.join(branchPath, "storage.json");
+  const marker = existsSync6(markerPath) ? readFileSync5(markerPath, "utf8") : "";
   if (marker.includes("kibi.rdf-journal.v1")) {
-    const rdfDirectory = path7.join(branchPath, "rdf");
-    const currentPath = path7.join(branchPath, "CURRENT");
-    const sentinelPath = path7.join(branchPath, "kb.rdf");
+    const rdfDirectory = path8.join(branchPath, "rdf");
+    const currentPath = path8.join(branchPath, "CURRENT");
+    const sentinelPath = path8.join(branchPath, "kb.rdf");
     if (!existsSync6(rdfDirectory) || !existsSync6(currentPath)) {
       recoverInterruptedGeneration(branchPath);
       if (existsSync6(rdfDirectory) && existsSync6(currentPath)) {
@@ -2320,9 +2344,9 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
         }
         return;
       }
-      const legacyRdf = path7.join(branchPath, "kb.rdf");
-      const legacyAudit = path7.join(branchPath, "audit.log");
-      const legacyContents = existsSync6(legacyRdf) ? readFileSync4(legacyRdf, "utf8") : "";
+      const legacyRdf = path8.join(branchPath, "kb.rdf");
+      const legacyAudit = path8.join(branchPath, "audit.log");
+      const legacyContents = existsSync6(legacyRdf) ? readFileSync5(legacyRdf, "utf8") : "";
       if (existsSync6(legacyAudit) || existsSync6(legacyRdf) && !legacyContents.includes("kibi.rdf-journal.v1")) {
         rmSync2(rdfDirectory, { recursive: true, force: true });
         rmSync2(currentPath, { force: true });
@@ -2340,29 +2364,29 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
       return;
     }
   }
-  const legacyRdf = path7.join(branchPath, "kb.rdf");
-  const legacyAudit = path7.join(branchPath, "audit.log");
+  const legacyRdf = path8.join(branchPath, "kb.rdf");
+  const legacyAudit = path8.join(branchPath, "audit.log");
   if (!existsSync6(legacyRdf) && !existsSync6(legacyAudit)) {
-    mkdirSync2(path7.join(branchPath, "rdf"), { recursive: true });
+    mkdirSync2(path8.join(branchPath, "rdf"), { recursive: true });
     writeFileSync2(markerPath, `{"format":"kibi.rdf-journal.v1","schemaVersion":1}
 `, { mode: 384 });
-    writeFileSync2(path7.join(branchPath, "CURRENT"), `generation-1:0
+    writeFileSync2(path8.join(branchPath, "CURRENT"), `generation-1:0
 `, {
       mode: 384
     });
-    writeFileSync2(path7.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
+    writeFileSync2(path8.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
     return;
   }
   if (existsSync6(legacyRdf)) {
-    const legacyContents = readFileSync4(legacyRdf, "utf8");
+    const legacyContents = readFileSync5(legacyRdf, "utf8");
     if (!/<rdf:RDF(?:\s|>)/.test(legacyContents)) {
       throw new Error(`Legacy Kibi store is corrupt at ${legacyRdf}: expected RDF/XML root`);
     }
   }
-  const parent = path7.dirname(branchPath);
-  const migrationKey = createHash2("sha256").update(path7.resolve(branchPath)).digest("hex").slice(0, 16);
-  const staging = path7.join(parent, `.${migrationKey}.migration.${process.pid}.${Date.now()}`);
+  const parent = path8.dirname(branchPath);
+  const migrationKey = createHash2("sha256").update(path8.resolve(branchPath)).digest("hex").slice(0, 16);
+  const staging = path8.join(parent, `.${migrationKey}.migration.${process.pid}.${Date.now()}`);
   mkdirSync2(staging, { recursive: true, mode: 448 });
   const testOneShot = false;
   const migrator = new PrologProcess({
@@ -2390,35 +2414,35 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
     await migrator.terminate();
   }
   for (const file of ["rdf", "storage.json", "CURRENT"]) {
-    const source = path7.join(staging, file);
+    const source = path8.join(staging, file);
     if (!existsSync6(source))
       continue;
-    const target = path7.join(branchPath, file);
+    const target = path8.join(branchPath, file);
     if (existsSync6(target))
       rmSync2(target, { recursive: true, force: true });
     renameSync(source, target);
   }
   archiveLegacyFiles(branchPath);
-  writeFileSync2(path7.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
+  writeFileSync2(path8.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
   fsyncJournaledBranchStore(branchPath);
   rmSync2(staging, { recursive: true, force: true });
 }
 function archiveLegacyFiles(branchPath) {
-  const legacyDir = path7.join(branchPath, "legacy");
+  const legacyDir = path8.join(branchPath, "legacy");
   mkdirSync2(legacyDir, { recursive: true, mode: 448 });
   for (const file of ["kb.rdf", "audit.log"]) {
-    const source = path7.join(branchPath, file);
+    const source = path8.join(branchPath, file);
     if (!existsSync6(source))
       continue;
     if (file === "kb.rdf") {
-      const contents = readFileSync4(source, "utf8");
+      const contents = readFileSync5(source, "utf8");
       if (contents.includes("kibi.rdf-journal.v1"))
         continue;
     }
-    const destination = path7.join(legacyDir, file);
+    const destination = path8.join(legacyDir, file);
     if (existsSync6(destination)) {
-      renameSync(source, path7.join(legacyDir, `${file}.recovery.${Date.now()}`));
+      renameSync(source, path8.join(legacyDir, `${file}.recovery.${Date.now()}`));
     } else {
       renameSync(source, destination);
     }
@@ -2434,12 +2458,12 @@ function recoverInterruptedGeneration(branchPath) {
   const newest = (prefix) => {
     const candidates = entries.filter((entry) => entry.startsWith(prefix)).sort().reverse();
     const candidate = candidates[0];
-    return candidate === undefined ? null : path7.join(branchPath, candidate);
+    return candidate === undefined ? null : path8.join(branchPath, candidate);
   };
   const oldRdf = newest("rdf.old.");
   const oldCurrent = newest("CURRENT.old.");
-  const rdfPath = path7.join(branchPath, "rdf");
-  const currentPath = path7.join(branchPath, "CURRENT");
+  const rdfPath = path8.join(branchPath, "rdf");
+  const currentPath = path8.join(branchPath, "CURRENT");
   if ((!existsSync6(rdfPath) || !existsSync6(currentPath)) && oldRdf && oldCurrent) {
     try {
       if (existsSync6(rdfPath))
@@ -2481,9 +2505,9 @@ class EngineSession {
   constructor(prolog, branchPath) {
     this.prolog = prolog;
     this.branchPath = branchPath;
-    const coreModuleDir = path7.dirname(resolveKbPlPath());
+    const coreModuleDir = path8.dirname(resolveKbPlPath());
     for (const [fileName, label] of ENGINE_PRELOADED_MODULES) {
-      const modulePath = path7.join(coreModuleDir, fileName);
+      const modulePath = path8.join(coreModuleDir, fileName);
       this.modules.push({
         goal: `use_module('${quoteProlog(modulePath.replaceAll("\\", "/"))}')`,
         label
@@ -2549,7 +2573,8 @@ async function runEngineDaemon(requestedOptions) {
   await session.boot();
   let attachedIdentity = readEngineAttachmentIdentity(branchPath);
   const serverPrologIdentity = engineSwiplIdentity();
-  mkdirSync2(path7.dirname(options.socketPath), { recursive: true, mode: 448 });
+  const serverPackageVersions = enginePackageVersions();
+  mkdirSync2(path8.dirname(options.socketPath), { recursive: true, mode: 448 });
   if (existsSync6(options.socketPath)) {
     const isLivePeerSignal = (error) => {
       if (error && typeof error === "object") {
@@ -2683,15 +2708,16 @@ async function runEngineDaemon(requestedOptions) {
     if (request.protocolVersion !== ENGINE_PROTOCOL_VERSION) {
       throw new Error(`Kibi engine protocol mismatch: client=${request.protocolVersion ?? "missing"}, server=${ENGINE_PROTOCOL_VERSION}`);
     }
-    const expectedPackages = process.env.KIBI_PACKAGE_VERSIONS;
-    if (expectedPackages !== undefined && request.packageVersions !== expectedPackages) {
-      throw new Error(`Kibi engine package-version mismatch: client=${request.packageVersions ?? "missing"}, server=${expectedPackages}`);
-    }
     if (canonicalFilesystemPath(request.workspaceRoot ?? "") !== options.workspaceRoot || request.branch !== options.branch) {
       throw new Error("Kibi engine workspace identity mismatch");
     }
-    if (request.method !== "handshake" && request.method !== "stop" && request.prologIdentity !== serverPrologIdentity) {
-      throw new Error(`Kibi engine SWI-Prolog mismatch: client=${request.prologIdentity ?? "missing"}, server=${serverPrologIdentity}`);
+    if (request.method !== "handshake" && request.method !== "stop") {
+      if (request.packageVersions !== serverPackageVersions) {
+        throw new Error(`Kibi engine package-version mismatch: client=${request.packageVersions ?? "missing"}, server=${serverPackageVersions}`);
+      }
+      if (request.prologIdentity !== serverPrologIdentity) {
+        throw new Error(`Kibi engine SWI-Prolog mismatch: client=${request.prologIdentity ?? "missing"}, server=${serverPrologIdentity}`);
+      }
     }
     if (!isEngineLifecycleRequest(request) && await session.ensureLive()) {
       queryCache.clear();
@@ -2911,7 +2937,10 @@ async function runEngineDaemon(requestedOptions) {
           throw new Error("export.targetDirectory is required");
         return prolog.query(`kb_storage_export('${quoteProlog(request.targetDirectory)}')`);
       case "handshake":
-        return { prologIdentity: serverPrologIdentity };
+        return {
+          prologIdentity: serverPrologIdentity,
+          packageVersions: serverPackageVersions
+        };
       case "stop":
         setImmediate(() => void shutdown());
         return { stopped: true };
@@ -2983,7 +3012,7 @@ async function runEngineDaemon(requestedOptions) {
               id: request.id,
               ok: false,
               error: "Kibi engine is shutting down; request was not executed",
-              serverPackageVersions: ENGINE_PACKAGE_VERSIONS
+              serverPackageVersions
             });
             return;
           }
@@ -2996,7 +3025,7 @@ async function runEngineDaemon(requestedOptions) {
                 id: request.id,
                 ok: false,
                 error: "Kibi engine request cancelled",
-                serverPackageVersions: ENGINE_PACKAGE_VERSIONS
+                serverPackageVersions
               });
               return;
             }
@@ -3006,14 +3035,14 @@ async function runEngineDaemon(requestedOptions) {
                 id: request.id,
                 ok: true,
                 result,
-                serverPackageVersions: ENGINE_PACKAGE_VERSIONS
+                serverPackageVersions
               });
             } catch (error) {
               writeSocketFrame(socket, {
                 id: request.id,
                 ok: false,
                 error: error instanceof Error ? error.message : String(error),
-                serverPackageVersions: ENGINE_PACKAGE_VERSIONS
+                serverPackageVersions
               });
             } finally {
               cancelledRequests.delete(request.id);
@@ -3057,7 +3086,7 @@ function isEngineDaemonEntrypoint(argv = process.argv, moduleUrl = import.meta.u
   if (typeof entry !== "string" || entry.length === 0)
     return false;
   try {
-    return moduleUrl === pathToFileURL(path8.resolve(entry)).href;
+    return moduleUrl === pathToFileURL(path9.resolve(entry)).href;
   } catch {
     return false;
   }