kibi-runtime 1.0.1 → 2.0.1

package/dist/engine-daemon.js

@@ -1,23 +1,26 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../cli/src/engine-daemon.ts
 import { writeFileSync as writeFileSync3 } from "node:fs";
+import path5 from "node:path";
+import { pathToFileURL } from "node:url";
 
 // ../cli/src/engine.ts
-import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import {
   chmodSync,
   closeSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   fsyncSync,
   mkdirSync as mkdirSync2,
   openSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync as readdirSync2,
   realpathSync,
   renameSync,
-  rmSync,
+  rmSync as rmSync2,
   statSync as statSync2,
   unlinkSync,
   writeFileSync as writeFileSync2
@@ -25,12 +28,11 @@ import {
 import * as net from "node:net";
 import * as os from "node:os";
 import * as path4 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../cli/src/prolog.ts
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -46,12 +48,347 @@ function isPrologDebugEnabled() {
   return Boolean(getEnvValue("KIBI_PROLOG_DEBUG"));
 }
 
+// ../cli/src/prolog/codec.ts
+function escapeAtom(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll("\x07", "\\a").replaceAll("\b", "\\b").replaceAll("\f", "\\f").replaceAll(`
+`, "\\n").replaceAll("\r", "\\r").replaceAll("\t", "\\t").replaceAll("\v", "\\v").replaceAll("'", "''");
+}
+function splitTopLevelGeneral(str, delimiter) {
+  return scanTopLevelGeneral(str, delimiter).parts;
+}
+function scanTopLevelGeneral(str, delimiter) {
+  const results = [];
+  let current = "";
+  let quote = null;
+  const delimiters = [];
+  let balanced = true;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (quote !== null) {
+      current += char;
+      if (char === "\\") {
+        const escaped = str[i + 1];
+        if (escaped !== undefined) {
+          current += escaped;
+          i++;
+        }
+      } else if (char === quote) {
+        const doubledPrologQuote = quote === "'" && str[i + 1] === "'";
+        if (doubledPrologQuote) {
+          current += str[i + 1] ?? "";
+          i++;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === "[" || char === "(" || char === "{") {
+      delimiters.push(char);
+      current += char;
+      continue;
+    }
+    if (char === "]" || char === ")" || char === "}") {
+      const expectedOpening = char === "]" ? "[" : char === ")" ? "(" : "{";
+      if (delimiters.at(-1) !== expectedOpening) {
+        balanced = false;
+      } else {
+        delimiters.pop();
+      }
+      current += char;
+      continue;
+    }
+    if (delimiters.length === 0 && delimiter.length > 0 && str.startsWith(delimiter, i)) {
+      if (current) {
+        results.push(current);
+        current = "";
+      }
+      i += delimiter.length - 1;
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    results.push(current);
+  }
+  return {
+    parts: results,
+    balanced: balanced && quote === null && delimiters.length === 0
+  };
+}
+
+// ../cli/src/prolog/error-terms.ts
+function extractPrologErrorRecord(text) {
+  const match = text.match(/^__KIBI_ERROR__:(.+)$/m);
+  const term = match?.[1];
+  if (term === undefined)
+    return null;
+  return parsePrologErrorTerm(term);
+}
+function parsePrologErrorTerm(termText) {
+  const trimmed = termText.trim();
+  const formalMatch = trimmed.match(/^error\((.*)\)$/s);
+  const formalAndContext = formalMatch?.[1];
+  if (formalAndContext === undefined)
+    return null;
+  const [formalRaw, contextRaw] = splitTopLevelGeneral(formalAndContext, ",");
+  if (!formalRaw)
+    return null;
+  const context = contextRaw ? parseContextTerm(contextRaw) : null;
+  const parsed = parseFormalTerm(formalRaw);
+  if (!parsed)
+    return null;
+  switch (parsed.kind) {
+    case "invalid_relationship": {
+      const formatted = contextRaw ? parseInvalidRelationshipContext(contextRaw) : null;
+      const relationship = formatted !== null ? substituteRelationshipArgs(formatted.formatTemplate, formatted.formatArgs) : null;
+      if (relationship === null) {
+        return {
+          code: "invalid_relationship",
+          message: "Invalid relationship type or direction"
+        };
+      }
+      return {
+        code: "invalid_relationship",
+        relationship,
+        message: `Invalid relationship: ${relationship.relType} from ${relationship.fromType} to ${relationship.toType}`
+      };
+    }
+    case "stale_snapshot":
+      return {
+        code: "stale_snapshot",
+        message: "KB snapshot is stale; reattach or refresh the runtime before retrying (stale_snapshot)"
+      };
+    case "audit_locked":
+      return {
+        code: "audit_locked",
+        message: "Audit journal is locked by another Kibi runtime; restart the stale MCP/CLI session before retrying"
+      };
+    case "store_locked": {
+      const detail = parseStoreLockedContext(contextRaw);
+      const holder = detail.owner;
+      const holderSummary = holder === null ? "an unidentified holder" : `pid ${holder.pid ?? "?"}${holder.workspaceRoot !== undefined ? ` for ${holder.workspaceRoot}` : ""}${holder.startedAt !== undefined ? ` since ${holder.startedAt}` : ""}`;
+      return {
+        code: "permission_denied",
+        storeLocked: detail,
+        message: `Branch store is locked by ${holderSummary}; close that session or, if it is dead, retry so Kibi can break the stale lock (store_locked)`
+      };
+    }
+    case "permission_denied":
+      return {
+        code: "permission_denied",
+        message: "Access denied or KB locked"
+      };
+    case "entity_not_found": {
+      const entityId = unquoteAtom(parsed.entityId);
+      const role = parseEntityRole(context?.message);
+      const verb = role === "source" ? "Source entity" : role === "target" ? "Target entity" : "Entity";
+      const record = {
+        code: "entity_not_found",
+        entityId,
+        message: `${verb} does not exist: ${entityId}`
+      };
+      return role === undefined ? record : { ...record, role };
+    }
+    case "contradiction": {
+      const conflicts = parsed.pairs.map((pair) => ({
+        reason: pair[0],
+        otherId: pair[1]
+      }));
+      return {
+        code: "contradiction",
+        conflicts,
+        message: context?.message ?? "Contradiction detected: conflicting requirements without a supersedes relationship"
+      };
+    }
+    case "validation_error":
+      return {
+        code: "validation_error",
+        message: parsed.message
+      };
+  }
+}
+function parseContextTerm(contextRaw) {
+  const contextMatch = contextRaw.trim().match(/^context\((.*)\)$/s);
+  if (contextMatch?.[1] === undefined) {
+    const message = unquoteAtom(contextRaw.trim());
+    return message === "" ? null : { message };
+  }
+  const parts = splitTopLevelGeneral(contextMatch[1], ",");
+  if (parts.length === 0)
+    return null;
+  const predicate = parts[0]?.trim();
+  const message = parts[1] ? unquoteAtom(parts[1].trim()) : "";
+  return {
+    ...predicate ? { predicate } : {},
+    ...message ? { message } : {}
+  };
+}
+function parseStoreLockedContext(contextRaw) {
+  const empty = {
+    owner: null,
+    lockDirectory: ""
+  };
+  if (!contextRaw)
+    return empty;
+  const inner = contextRaw.trim().match(/^kb_store_locked\((.*)\)$/s)?.[1];
+  if (inner === undefined)
+    return empty;
+  const parts = splitTopLevelGeneral(inner, ",");
+  const ownerRaw = parts[0]?.trim();
+  const lockRaw = parts[1]?.trim();
+  const lockDirectory = lockRaw ? unquoteAtom(lockRaw) : "";
+  const originalRaw = parts[2]?.trim();
+  const originalError = originalRaw ? unquoteAtom(originalRaw) : "";
+  if (!ownerRaw || ownerRaw === '""' || ownerRaw === "''") {
+    return {
+      owner: null,
+      lockDirectory,
+      ...originalError !== "" ? { originalError } : {}
+    };
+  }
+  try {
+    const parsed = JSON.parse(unquoteAtom(ownerRaw));
+    if (parsed === null || typeof parsed !== "object") {
+      return {
+        owner: null,
+        lockDirectory,
+        ...originalError !== "" ? { originalError } : {}
+      };
+    }
+    return {
+      owner: {
+        ...typeof parsed.pid === "number" ? { pid: parsed.pid } : {},
+        ...typeof parsed.workspaceRoot === "string" ? { workspaceRoot: parsed.workspaceRoot } : {},
+        ...typeof parsed.bootId === "string" ? { bootId: parsed.bootId } : {},
+        ...typeof parsed.startedAt === "string" ? { startedAt: parsed.startedAt } : {}
+      },
+      lockDirectory,
+      ...originalError !== "" ? { originalError } : {}
+    };
+  } catch {
+    return {
+      owner: null,
+      lockDirectory,
+      ...originalError !== "" ? { originalError } : {}
+    };
+  }
+}
+function parseFormalTerm(formalRaw) {
+  const formal = formalRaw.trim();
+  const functorMatch = formal.match(/^([a-z][A-Za-z0-9_]*)\((.*)\)$/s);
+  if (functorMatch?.[1] === undefined || functorMatch[2] === undefined) {
+    return null;
+  }
+  const functor = functorMatch[1];
+  const args = functorMatch[2].trim() ? splitTopLevelGeneral(functorMatch[2], ",") : [];
+  if (functor === "permission_error") {
+    const operation = args[0]?.trim();
+    const resource = args[1]?.trim();
+    const detail = args[2]?.trim();
+    if (detail === "stale_snapshot")
+      return { kind: "stale_snapshot" };
+    if (operation === "lock" && resource === "audit_log") {
+      return { kind: "audit_locked" };
+    }
+    if (operation === "attach" && resource === "kb_store") {
+      return { kind: "store_locked" };
+    }
+    return { kind: "permission_denied" };
+  }
+  if (functor === "existence_error" && args[0]?.trim() === "entity") {
+    const entityId = args[1]?.trim();
+    if (entityId === undefined)
+      return null;
+    return { kind: "entity_not_found", entityId: unquoteAtom(entityId) };
+  }
+  if (functor === "type_error" && args[0]?.trim() === "relationship") {
+    return { kind: "invalid_relationship" };
+  }
+  if (functor === "kb_contradiction") {
+    const listText = args[0]?.trim() ?? "[]";
+    const pairs = parseContradictionPairs(listText);
+    return { kind: "contradiction", pairs };
+  }
+  if (functor === "validation_error") {
+    const message = args[0]?.trim();
+    if (message === undefined)
+      return null;
+    return { kind: "validation_error", message: unquoteAtom(message) };
+  }
+  return null;
+}
+function parseInvalidRelationshipContext(contextRaw) {
+  const contextMatch = contextRaw.trim().match(/^context\((.*)\)$/s);
+  const inner = contextMatch?.[1];
+  if (inner === undefined)
+    return null;
+  const parts = splitTopLevelGeneral(inner, ",");
+  const formatted = parts[1]?.trim();
+  if (formatted === undefined)
+    return null;
+  const formatMatch = formatted.match(/^(.*)-\[(.*)\]$/s);
+  const template = formatMatch?.[1];
+  const argsText = formatMatch?.[2];
+  if (template === undefined || argsText === undefined)
+    return null;
+  const formatArgs = argsText.trim() ? splitTopLevelGeneral(argsText, ",").map((arg) => unquoteAtom(arg.trim())) : [];
+  return { formatTemplate: unquoteAtom(template.trim()), formatArgs };
+}
+function substituteRelationshipArgs(template, args) {
+  if (template === null || args === null || args.length < 3)
+    return null;
+  const substituted = template.split("~w").map((chunk, index) => index === 0 ? chunk : `${args[index - 1] ?? ""}${chunk}`).join("");
+  const match = substituted.match(/^Invalid relationship:\s*(\S+)\s+from\s+(\S+)\s+to\s+(\S+)\s*$/);
+  if (!match?.[1] || !match[2] || !match[3])
+    return null;
+  return {
+    relType: match[1],
+    fromType: match[2],
+    toType: match[3]
+  };
+}
+function parseContradictionPairs(listText) {
+  const trimmed = listText.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
+    return [];
+  const inner = trimmed.slice(1, -1).trim();
+  if (inner === "")
+    return [];
+  return splitTopLevelGeneral(inner, ",").map((item) => splitTopLevelGeneral(item.trim(), "-")).map((pair) => {
+    const reason = pair[0] ?? "";
+    const otherId = pair[1] ?? "";
+    return [unquoteAtom(reason.trim()), unquoteAtom(otherId.trim())];
+  }).filter((pair) => pair[0] !== "" && pair[1] !== "");
+}
+function parseEntityRole(message) {
+  if (message?.includes("Source entity does not exist"))
+    return "source";
+  if (message?.includes("Target entity does not exist"))
+    return "target";
+  return;
+}
+function unquoteAtom(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    const inner = trimmed.slice(1, -1);
+    return inner.replace(/\\'/g, "'").replace(/\\\\/g, "\\").replace(/\\n/g, `
+`).replace(/\\t/g, "\t");
+  }
+  return trimmed;
+}
+
 // ../cli/src/prolog.ts
 var importMetaDir = path.dirname(fileURLToPath(import.meta.url));
 var 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 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 function packageVersion(packagePath) {
   try {
     const packageJson = require2(packagePath);
@@ -89,6 +426,17 @@ function resolveKbPlPath() {
   }
   throw new Error("Unable to resolve kb.pl. Expected kibi-core to be installed (node_modules) " + "or to be running inside the monorepo checkout.");
 }
+function registerProcessExitOnce(current, handler, on = (event, listener) => process.on(event, listener)) {
+  if (current)
+    return current;
+  on("exit", handler);
+  return handler;
+}
+function bindProcessExitHandler(current, terminate, on = (event, listener) => process.on(event, listener)) {
+  return registerProcessExitOnce(current, () => {
+    terminate();
+  }, on);
+}
 
 class PrologProcess {
   process = null;
@@ -111,6 +459,9 @@ class PrologProcess {
     this.timeout = options.timeout || 30000;
     this.useOneShotMode = options.oneShot ?? false;
   }
+  attachProcessExitHandler(on = (event, listener) => process.on(event, listener)) {
+    this.onProcessExit = bindProcessExitHandler(this.onProcessExit, () => this.terminate(), on);
+  }
   async start() {
     if (!existsSync(this.swiplPath) && this.swiplPath !== "swipl") {
       throw new Error(`SWI-Prolog not found at ${this.swiplPath}. Please install SWI-Prolog or check your PATH.`);
@@ -141,19 +492,14 @@ class PrologProcess {
     });
     this.process.stdin.write(`true.
 `);
-    if (!this.onProcessExit) {
-      this.onProcessExit = () => {
-        this.terminate();
-      };
-      process.on("exit", this.onProcessExit);
-    }
+    this.attachProcessExitHandler();
     await this.waitForReady();
   }
   async waitForReady() {
     const start = Date.now();
     const maxStartWait = 2000;
     while (Date.now() - start < maxStartWait) {
-      if (!this.process || this.process.killed) {
+      if (!this.process || this.process.killed || this.process.exitCode !== null || this.process.signalCode !== null) {
         throw new Error(`Prolog process terminated unexpectedly during startup: ${this.translateError(this.errorBuffer)}`);
       }
       if (this.errorBuffer.includes("ERROR")) {
@@ -209,7 +555,8 @@ class PrologProcess {
       const goalLabel = this.goalLabel(normalizedGoal);
       const shouldPersist = this.isMutatingGoal(normalizedGoal) && !normalizedGoal.includes("kb_save") && !normalizedGoal.includes("kb_commit_upsert");
       const goalWithPersistence = shouldPersist ? `(${normalizedGoal}, kb_save)` : normalizedGoal;
-      const wrappedGoal = /^once\s*\(/.test(goalWithPersistence) ? `catch(${goalWithPersistence}, _E, (print_message(error, _E), fail))` : `catch(once((${goalWithPersistence})), _E, (print_message(error, _E), fail))`;
+      const errorReport = `(write(user_error, '__KIBI_ERROR__:'), write_term(user_error, _E, [quoted(true), max_depth(8)]), nl(user_error), print_message(error, _E), fail)`;
+      const wrappedGoal = /^once\s*\(/.test(goalWithPersistence) ? `catch(${goalWithPersistence}, _E, ${errorReport})` : `catch(once((${goalWithPersistence})), _E, ${errorReport})`;
       const start = Date.now();
       if (debug) {
         console.error(`[prolog debug] start query: ${goalLabel}`);
@@ -221,7 +568,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
         let settled = false;
         const timeoutId = setTimeout(() => {
           const stage = this.lastDiagnosticStage(this.errorBuffer) ?? "unknown";
-          const msg = `Query timeout after ${this.timeout / 1000}s (stage=${stage}, pid=${this.process?.pid ?? 0}, killed=${this.process?.killed ? "yes" : "no"}, exitCode=${this.process?.exitCode ?? "null"}, goal=${goalLabel})`;
+          const msg = `Query timeout after ${this.timeout / 1000}s (stage=${stage}, pid=${this.process?.pid ?? 0}, killed=${this.process?.killed ? "yes" : "no"}, exitCode=${this.process?.exitCode ?? "null"}, signal=${this.process?.signalCode ?? "null"}, goal=${goalLabel}). If several fresh Kibi commands hang or crawl the same way, the engine state is likely wedged: run 'kibi engine stop' (then 'kibi sync --rebuild' if needed) and retry.`;
           if (debug) {
             console.error(`[prolog debug] timeout: ${msg}`);
             const runtime = this.errorBuffer.split(`
@@ -266,10 +613,12 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
               console.error(`[prolog debug] query error: ${goalLabel} error=${this.errorBuffer.split(`
 `)[0]}`);
             }
+            const classified = this.classifyErrorOutput(this.errorBuffer);
             resolve({
               success: false,
               bindings: {},
-              error: this.addDiagnosticStage(this.translateError(this.errorBuffer), normalizedGoal, this.errorBuffer)
+              error: this.addDiagnosticStage(classified.message, normalizedGoal, this.errorBuffer),
+              ...classified.record ? { errorRecord: classified.record } : {}
             });
             return;
           }
@@ -392,7 +741,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
       "read_term_from_atom(GoalAtom, Goal, [variable_names(Vars)])",
       kbPath ? "getenv('KIBI_KB_PATH', KBPath), kb_attach(KBPath)" : "true",
       isBatch ? "WrappedGoal = rdf_transaction(Goal)" : "WrappedGoal = Goal",
-      "(catch(call(WrappedGoal), E, (print_message(error, E), fail)) -> QuerySucceeded = true ; QuerySucceeded = false)",
+      "(catch(call(WrappedGoal), E, (write(user_error, '__KIBI_ERROR__:'), write_term(user_error, E, [quoted(true), max_depth(8)]), nl(user_error), print_message(error, E), fail)) -> QuerySucceeded = true ; QuerySucceeded = false)",
       kbPath && (explicitSaveRequested || goalList.some((item) => this.isMutatingGoal(item))) ? "(QuerySucceeded == true -> kb_save ; true)" : "true",
       kbPath ? "kb_detach" : "true",
       "(QuerySucceeded == true -> (forall(member(Name=Value, Vars), (write(Name), write('='), write_term(Value, [quoted(true), max_depth(0)]), writeln('.'))), writeln('__KIBI_TRUE__.')) ; writeln('__KIBI_FALSE__.'))"
@@ -505,10 +854,12 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
       };
     }
     if (stderr.includes("ERROR")) {
+      const classified = this.classifyErrorOutput(stderr);
       return {
         success: false,
         bindings: {},
-        error: this.addDiagnosticStage(this.translateError(stderr), combinedGoal ?? "true", stderr)
+        error: this.addDiagnosticStage(classified.message, combinedGoal ?? "true", stderr),
+        ...classified.record ? { errorRecord: classified.record } : {}
       };
     }
     if (stdout.includes("__KIBI_TRUE__")) {
@@ -622,7 +973,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     }
   }
   isProcessUsable() {
-    return Boolean(this.process?.stdin && !this.process?.killed && this.process?.exitCode === null);
+    return Boolean(this.process?.stdin && !this.process?.killed && this.process?.exitCode === null && this.process?.signalCode === null);
   }
   extractBindings(output) {
     const bindings = {};
@@ -651,8 +1002,15 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     flush();
     return bindings;
   }
+  classifyErrorOutput(errorText) {
+    const record = extractPrologErrorRecord(errorText);
+    if (record) {
+      return { message: record.message, record };
+    }
+    return { message: this.translateError(errorText) };
+  }
   translateError(errorText) {
-    const cleanError = errorText.replace(/^__KIBI_(?:STAGE|RUNTIME)__:[^\r\n]*\r?\n?/gm, "");
+    const cleanError = errorText.replace(/^__KIBI_(?:STAGE|RUNTIME|ERROR)__:[^\r\n]*\r?\n?/gm, "");
     if (cleanError.includes("stale_snapshot")) {
       return "KB snapshot is stale; reattach or refresh the runtime before retrying (stale_snapshot)";
     }
@@ -696,7 +1054,7 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     return simpleError || "Unknown error";
   }
   isRunning() {
-    return Boolean(this.process && !this.process.killed && this.process?.exitCode === null);
+    return Boolean(this.process && !this.process.killed && this.process?.exitCode === null && this.process?.signalCode === null);
   }
   getPid() {
     return this.process?.pid || 0;
@@ -731,223 +1089,105 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
   }
 }
 
-// ../cli/src/prolog/codec.ts
-function parseListOfLists(listStr) {
-  const cleaned = listStr.trim().replace(/^\[/, "").replace(/\]$/, "");
-  if (cleaned === "") {
-    return [];
+// ../cli/src/prolog/store-lock.ts
+import { existsSync as existsSync2, rmSync } from "node:fs";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var cachedBootId;
+function currentBootId() {
+  if (cachedBootId !== undefined)
+    return cachedBootId;
+  if (process.platform !== "linux") {
+    cachedBootId = null;
+    return cachedBootId;
   }
-  const results = [];
-  let depth = 0;
-  let current = "";
-  let currentList = [];
-  for (let i = 0;i < cleaned.length; i++) {
-    const char = cleaned[i];
-    if (char === "[") {
-      depth++;
-      if (depth > 1)
-        current += char;
-    } else if (char === "]") {
-      depth--;
-      if (depth === 0) {
-        if (current) {
-          currentList.push(current.trim());
-          current = "";
-        }
-        if (currentList.length > 0) {
-          results.push(currentList);
-          currentList = [];
-        }
-      } else {
-        current += char;
-      }
-    } else if (char === "," && depth === 1) {
-      if (current) {
-        currentList.push(current.trim());
-        current = "";
-      }
-    } else if (char === "," && depth === 0) {} else {
-      current += char;
-    }
+  try {
+    const raw = readFileSync("/proc/sys/kernel/random/boot_id", "utf8");
+    cachedBootId = raw.trim();
+  } catch {
+    cachedBootId = null;
   }
-  return results;
+  return cachedBootId;
 }
-function parseEntityFromList(data) {
-  if (data.length < 3) {
-    return {};
-  }
-  const [idPart, typePart, propsPart] = data;
-  if (idPart === undefined || typePart === undefined || propsPart === undefined) {
-    return {};
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error?.code;
+    return code === "EPERM";
   }
-  const id = idPart.trim();
-  const type = typePart.trim();
-  const propsStr = propsPart.trim();
-  const props = parsePropertyList(propsStr);
-  return { ...props, id: normalizeEntityId(stripOuterQuotes(id)), type };
 }
-function parsePropertyList(propsStr) {
-  const props = {};
-  let cleaned = propsStr.trim();
-  if (cleaned.startsWith("[")) {
-    cleaned = cleaned.substring(1);
-  }
-  if (cleaned.endsWith("]")) {
-    cleaned = cleaned.substring(0, cleaned.length - 1);
-  }
-  const pairs = splitTopLevelGeneral(cleaned, ",");
-  for (const pair of pairs) {
-    const eqIndex = pair.indexOf("=");
-    if (eqIndex === -1)
-      continue;
-    const key = pair.substring(0, eqIndex).trim();
-    const value = pair.substring(eqIndex + 1).trim();
-    if (key === "..." || value === "..." || value === "...|...") {
-      continue;
-    }
-    let parsed = parsePrologValue(value);
-    if ((key === "rule_ir" || key === "semantic_inventory" || key === "verification_receipts" || key === "verification_contract") && typeof parsed === "string") {
-      try {
-        parsed = JSON.parse(parsed);
-      } catch {}
-    }
-    if (!Object.hasOwn(props, key)) {
-      props[key] = parsed;
-      continue;
-    }
-    const existing = props[key];
-    props[key] = Array.isArray(existing) ? [...existing, parsed] : [existing, parsed];
-  }
-  return props;
-}
-function parsePrologValue(valueInput) {
-  const value = valueInput.trim();
-  if (value.startsWith("^^(")) {
-    const innerStart = value.indexOf("(") + 1;
-    let depth = 1;
-    let innerEnd = innerStart;
-    for (let i = innerStart;i < value.length; i++) {
-      if (value[i] === "(")
-        depth++;
-      if (value[i] === ")") {
-        depth--;
-        if (depth === 0) {
-          innerEnd = i;
-          break;
-        }
-      }
-    }
-    const innerContent = value.substring(innerStart, innerEnd);
-    const parts = splitTopLevelGeneral(innerContent, ",");
-    if (parts.length >= 2) {
-      const literalPart = parts[0];
-      const datatypePart = parts[1];
-      if (literalPart === undefined || datatypePart === undefined) {
-        return value;
-      }
-      let literalValue = literalPart.trim();
-      const datatype = datatypePart.trim();
-      if (literalValue.startsWith('"') && literalValue.endsWith('"')) {
-        literalValue = literalValue.substring(1, literalValue.length - 1);
-      }
-      if (datatype.includes("#integer")) {
-        return Number.parseInt(literalValue, 10);
-      }
-      if (datatype.includes("#decimal") || datatype.includes("#double")) {
-        return Number.parseFloat(literalValue);
-      }
-      if (datatype.includes("#boolean")) {
-        return literalValue === "true";
-      }
-      if (literalValue.startsWith("[") && literalValue.endsWith("]")) {
-        const listContent = literalValue.substring(1, literalValue.length - 1);
-        if (listContent === "") {
-          return [];
-        }
-        return splitTopLevelGeneral(listContent, ",").map((item) => item.trim());
-      }
-      return literalValue;
-    }
-  }
-  if (value.startsWith("file:///")) {
-    const lastSlash = value.lastIndexOf("/");
-    if (lastSlash !== -1) {
-      return value.substring(lastSlash + 1);
-    }
-    return value;
-  }
-  if (value.startsWith('"') && value.endsWith('"')) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value.substring(1, value.length - 1);
-    }
-  }
-  if (value.startsWith("'") && value.endsWith("'")) {
-    return value.substring(1, value.length - 1);
-  }
-  if (value.startsWith("[") && value.endsWith("]")) {
-    const listContent = value.substring(1, value.length - 1);
-    if (listContent === "") {
-      return [];
-    }
-    const items = splitTopLevelGeneral(listContent, ",").map((item) => {
-      return parsePrologValue(item.trim());
-    });
-    return items;
-  }
-  return value;
+function classifyStoreLockHolder(owner) {
+  if (owner === null || typeof owner.pid !== "number")
+    return "unknown";
+  if (owner.pid === process.pid)
+    return "self";
+  const alive = isProcessAlive(owner.pid);
+  if (!alive)
+    return "dead";
+  const bootId = currentBootId();
+  if (bootId !== null && owner.bootId !== undefined && owner.bootId !== "") {
+    return owner.bootId === bootId ? "alive" : "dead";
+  }
+  return "alive";
 }
-function splitTopLevelGeneral(str, delimiter) {
-  const results = [];
-  let current = "";
-  let depth = 0;
-  let inDoubleQuotes = false;
-  let inSingleQuotes = false;
-  for (let i = 0;i < str.length; i++) {
-    const char = str[i];
-    const prevChar = i > 0 ? str[i - 1] : "";
-    if (char === '"' && !inSingleQuotes && prevChar !== "\\") {
-      inDoubleQuotes = !inDoubleQuotes;
-      current += char;
-    } else if (char === "'" && !inDoubleQuotes && prevChar !== "\\") {
-      inSingleQuotes = !inSingleQuotes;
-      current += char;
-    } else if (!inDoubleQuotes && !inSingleQuotes && (char === "[" || char === "(")) {
-      depth++;
-      current += char;
-    } else if (!inDoubleQuotes && !inSingleQuotes && (char === "]" || char === ")")) {
-      depth--;
-      current += char;
-    } else if (!inDoubleQuotes && !inSingleQuotes && depth === 0 && char === delimiter) {
-      if (current) {
-        results.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
+function breakStoreLock(rdfDirectory) {
+  const candidates = [
+    join(rdfDirectory, "lock"),
+    join(rdfDirectory, ".kibi-lock-owner.json"),
+    join(dirname(rdfDirectory), ".kibi-lock-owner.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      rmSync(candidate, { force: true });
     }
   }
-  if (current) {
-    results.push(current);
-  }
-  return results;
 }
-function stripOuterQuotes(value) {
-  if (value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return value.slice(1, -1);
+function decideStoreLockTakeover(owner) {
+  const state = classifyStoreLockHolder(owner);
+  switch (state) {
+    case "dead":
+      return {
+        action: "break",
+        reason: `recorded holder pid ${owner?.pid ?? "?"} is no longer running`
+      };
+    case "unknown":
+      return {
+        action: "surface",
+        reason: "no ownership journal; the holder cannot be verified"
+      };
+    case "self":
+    case "alive":
+      return {
+        action: "surface",
+        reason: `holder pid ${owner?.pid ?? "?"} is still running${owner?.workspaceRoot !== undefined ? ` for ${owner.workspaceRoot}` : ""}`
+      };
   }
-  return value;
 }
-function normalizeEntityId(value) {
-  if (!value.startsWith("file:///")) {
-    return value;
+async function retryAttachAfterBreakingStaleLock(prolog, kbPath, failed) {
+  const record = failed.errorRecord;
+  const storeLocked = record?.storeLocked;
+  if (storeLocked === undefined)
+    return failed;
+  const decision = decideStoreLockTakeover(storeLocked.owner);
+  if (decision.action !== "break") {
+    const holderSummary = storeLocked.owner === null ? decision.reason : `pid ${storeLocked.owner.pid ?? "?"} (${decision.reason})`;
+    return {
+      ...failed,
+      error: `${failed.error}
+Store lock holder: ${holderSummary}. Close that session, or run 'kibi engine stop' for its workspace, then retry.`
+    };
+  }
+  const lockDirectory = storeLocked.lockDirectory !== "" ? storeLocked.lockDirectory : join(kbPath, "rdf");
+  breakStoreLock(lockDirectory);
+  const retried = await prolog.query(`kb_attach('${escapeAtom(kbPath)}')`);
+  if (retried.success) {
+    console.warn(`[KIBI] Broke a stale branch-store lock (${decision.reason}) and reattached.`);
   }
-  const idx = value.lastIndexOf("/");
-  return idx === -1 ? value : value.slice(idx + 1);
+  return retried;
 }
 
 // ../cli/src/utils/branch-resolver.ts
@@ -960,9 +1200,9 @@ import * as path3 from "node:path";
 // ../cli/src/utils/branch-store-locator.ts
 import { createHash } from "node:crypto";
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   readdirSync,
   statSync,
   writeFileSync
@@ -990,10 +1230,10 @@ function expectedBranchStoreManifest(branch) {
 }
 function readBranchStoreManifest(storePath) {
   const manifestPath = branchStoreManifestPath(storePath);
-  if (!existsSync2(manifestPath))
+  if (!existsSync3(manifestPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
     if (parsed.version !== BRANCH_STORE_MANIFEST_VERSION || typeof parsed.branch !== "string" || typeof parsed.key !== "string") {
       return null;
     }
@@ -1020,7 +1260,7 @@ function ensureBranchStoreManifest(workspaceRoot, branch) {
     throw new Error(`Branch store identity mismatch at ${storePath}; refusing to attach it to '${branch}'.`);
   }
   if (existing === null) {
-    if (existsSync2(manifestPath)) {
+    if (existsSync3(manifestPath)) {
       throw new Error(`Branch store manifest is invalid at ${manifestPath}; refusing to overwrite it.`);
     }
     const entries = readdirSync(storePath);
@@ -1082,11 +1322,41 @@ var ENGINE_PACKAGE_VERSIONS = process.env.KIBI_PACKAGE_VERSIONS ?? "unknown";
 var ENGINE_QUERY_CACHE_MAX_ENTRIES = 128;
 var ENGINE_QUERY_CACHE_MAX_RESULT_BYTES = 8 * 1024 * 1024;
 var ENGINE_FRESHNESS_CACHE_MS = 100;
-var ENGINE_PUBLICATION_LOCK_STALE_MS = 5000;
+var ENGINE_WORKSPACE_WATCHDOG_MS = 30000;
+function requestEngineSignalShutdown(shutdown) {
+  return () => {
+    shutdown();
+  };
+}
+function readJournalGeneration(branchPath) {
+  const currentPath = path4.join(branchPath, "CURRENT");
+  if (!existsSync4(currentPath))
+    return "";
+  return readFileSync3(currentPath, "utf8").trim();
+}
+function readEngineAttachmentIdentity(branchPath) {
+  if (!existsSync4(branchPath))
+    return null;
+  const stats = statSync2(branchPath);
+  let resolved = path4.resolve(branchPath);
+  try {
+    resolved = realpathSync(branchPath);
+  } catch {}
+  return {
+    path: resolved,
+    generation: readJournalGeneration(branchPath),
+    dev: stats.dev,
+    ino: stats.ino
+  };
+}
 function engineIdleTimeoutMs() {
   const configured = Number.parseInt(process.env.KIBI_ENGINE_IDLE_TIMEOUT_MS ?? "", 10);
   return Number.isFinite(configured) && configured >= 100 ? configured : ENGINE_IDLE_TIMEOUT_MS;
 }
+function engineWorkspaceWatchdogMs() {
+  const configured = Number.parseInt(process.env.KIBI_ENGINE_WORKSPACE_WATCHDOG_MS ?? "", 10);
+  return Number.isFinite(configured) && configured >= 100 ? configured : ENGINE_WORKSPACE_WATCHDOG_MS;
+}
 function quoteProlog(value) {
   return value.replaceAll("'", "''");
 }
@@ -1215,7 +1485,7 @@ function runtimeDirectory() {
   throw new Error("Unable to create a writable Kibi engine runtime directory");
 }
 function fsyncPath(filePath) {
-  if (!existsSync3(filePath))
+  if (!existsSync4(filePath))
     return;
   let descriptor = null;
   try {
@@ -1229,7 +1499,7 @@ function fsyncPath(filePath) {
 function fsyncJournaledBranchStore(branchPath) {
   const rdfRoot = path4.join(branchPath, "rdf");
   const directories = [];
-  const pending = existsSync3(rdfRoot) ? [rdfRoot] : [];
+  const pending = existsSync4(rdfRoot) ? [rdfRoot] : [];
   while (pending.length > 0) {
     const directory = pending.pop();
     if (directory === undefined)
@@ -1273,115 +1543,13 @@ function enginePidPath(workspaceRoot, branch) {
   }
   return `${socket}.pid`;
 }
-function engineStartLockPath(workspaceRoot, branch) {
-  if (process.platform === "win32") {
-    return path4.join(runtimeDirectory(), `kibi-${createHash2("sha256").update(`${path4.resolve(workspaceRoot)}\x00${branch}`).digest("hex")}.start.lock`);
-  }
-  return `${engineSocketPath(workspaceRoot, branch)}.start.lock`;
-}
-function enginePublicationLockPath(workspaceRoot, branch) {
-  return `${engineSocketPath(workspaceRoot, branch)}.publish.lock`;
-}
-function publicationLockOwner(lockPath) {
-  try {
-    const [pidText, createdText] = readFileSync2(lockPath, "utf8").trim().split(":");
-    const pid = Number.parseInt(pidText ?? "", 10);
-    const createdAt = Number.parseInt(createdText ?? "", 10);
-    if (!Number.isInteger(pid) || pid <= 1 || !Number.isFinite(createdAt)) {
-      return null;
-    }
-    return { pid, createdAt };
-  } catch {
-    return null;
-  }
-}
-function processIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function clearStalePublicationLock(lockPath) {
-  if (!existsSync3(lockPath))
-    return true;
-  const owner = publicationLockOwner(lockPath);
-  let age = 0;
-  try {
-    age = Date.now() - statSync2(lockPath).mtimeMs;
-  } catch {
-    return false;
-  }
-  if ((owner === null || !processIsAlive(owner.pid)) && age > ENGINE_PUBLICATION_LOCK_STALE_MS) {
-    try {
-      unlinkSync(lockPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return false;
-}
-function publicationLockIsActive(lockPath) {
-  if (!existsSync3(lockPath))
-    return false;
-  if (clearStalePublicationLock(lockPath))
-    return false;
-  return existsSync3(lockPath);
-}
-function tryAcquireStartLock(lockPath) {
-  try {
-    const descriptor = openSync(lockPath, "wx", 384);
-    writeFileSync2(lockPath, `${process.pid}:${Date.now()}
-`, { flag: "w" });
-    return descriptor;
-  } catch {
-    try {
-      const stamp = readFileSync2(lockPath, "utf8").trim().split(":");
-      const pid = Number.parseInt(stamp[0] ?? "", 10);
-      const created = Number.parseInt(stamp[1] ?? "", 10);
-      let age = 0;
-      try {
-        age = Date.now() - statSync2(lockPath).mtimeMs;
-      } catch {
-        age = 0;
-      }
-      if (!Number.isFinite(created) && age <= 5000)
-        return null;
-      let alive = false;
-      if (Number.isFinite(pid) && pid > 0) {
-        try {
-          process.kill(pid, 0);
-          alive = true;
-        } catch {
-          alive = false;
-        }
-      }
-      if (!alive && (Number.isFinite(created) ? Date.now() - created > 5000 : age > 5000)) {
-        unlinkSync(lockPath);
-      }
-    } catch {}
-    return null;
-  }
-}
-function releaseStartLock(lockPath, descriptor) {
-  if (descriptor !== null) {
-    try {
-      closeSync(descriptor);
-    } catch {}
-  }
-  try {
-    unlinkSync(lockPath);
-  } catch {}
-}
 function recoverStaleJournalLock(branchPath) {
   const lockPath = path4.join(branchPath, "rdf", "lock");
-  if (!existsSync3(lockPath))
+  if (!existsSync4(lockPath))
     return;
   let contents = "";
   try {
-    contents = readFileSync2(lockPath, "utf8");
+    contents = readFileSync3(lockPath, "utf8");
   } catch {
     return;
   }
@@ -1396,25 +1564,12 @@ function recoverStaleJournalLock(branchPath) {
     return;
   } catch {
     try {
-      rmSync(lockPath, { force: true });
+      rmSync2(lockPath, { force: true });
     } catch {}
   }
 }
-function daemonEntry() {
-  const moduleDirectory = path4.dirname(fileURLToPath2(import.meta.url));
-  const candidates = [
-    path4.join(moduleDirectory, "engine-daemon.js"),
-    path4.join(moduleDirectory, "..", "dist", "engine-daemon.js"),
-    path4.join(moduleDirectory, "..", "node_modules", "kibi-cli", "dist", "engine-daemon.js")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync3(candidate))
-      return candidate;
-  }
-  throw new Error("The Kibi engine is not built. Run `npm run build:cli` before using the CLI engine.");
-}
 function connectSocket(socketPath, timeoutMs) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     const socket = net.createConnection(socketPath);
     let settled = false;
     const timer = setTimeout(() => {
@@ -1429,7 +1584,7 @@ function connectSocket(socketPath, timeoutMs) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve3(socket);
+      resolve(socket);
     });
     socket.on("error", (error) => {
       if (settled)
@@ -1440,409 +1595,39 @@ function connectSocket(socketPath, timeoutMs) {
     });
   });
 }
-async function connectWithRetry(socketPath, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  let lastError;
-  while (Date.now() < deadline) {
-    const errorPath = `${socketPath}.error`;
-    if (existsSync3(errorPath)) {
-      try {
-        const diagnostic = readFileSync2(errorPath, "utf8").trim();
-        if (diagnostic)
-          throw new Error(diagnostic);
-      } catch (error) {
-        throw new Error(`Kibi engine failed to start: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    if (process.platform !== "win32" && !existsSync3(socketPath)) {
-      await new Promise((resolve3) => setTimeout(resolve3, 25));
-      continue;
-    }
-    try {
-      return await connectSocket(socketPath, Math.min(250, deadline - Date.now()));
-    } catch (error) {
-      lastError = error;
-      await new Promise((resolve3) => setTimeout(resolve3, 25));
-    }
-  }
-  throw new Error(`Unable to connect to Kibi engine at ${socketPath}: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
-}
-
-class EngineClient {
-  workspaceRoot;
-  branch;
-  timeout;
-  allowPublicationLock;
-  socket = null;
-  daemon = null;
-  inputBuffer = Buffer.alloc(0);
-  requestId = 0;
-  pending = new Map;
-  requestTail = Promise.resolve();
-  lastResult = null;
-  constructor(options) {
-    if (!isValidBranchName(options.branch)) {
-      throw new Error(`Invalid Kibi engine branch name: ${options.branch}`);
-    }
-    const resolvedWorkspaceRoot = path4.resolve(options.workspaceRoot);
-    try {
-      this.workspaceRoot = realpathSync(resolvedWorkspaceRoot);
-    } catch {
-      this.workspaceRoot = resolvedWorkspaceRoot;
-    }
-    this.branch = options.branch;
-    this.timeout = options.timeout ?? 120000;
-    this.allowPublicationLock = options.allowPublicationLock ?? false;
-  }
-  async start(allowSpawn = true) {
-    if (this.socket !== null && !this.socket.destroyed)
-      return;
-    const socketPath = engineSocketPath(this.workspaceRoot, this.branch);
-    const publicationLockPath = enginePublicationLockPath(this.workspaceRoot, this.branch);
-    if (!this.allowPublicationLock && publicationLockIsActive(publicationLockPath)) {
-      throw new Error(`Kibi engine publication is in progress: ${publicationLockPath}`);
-    }
-    try {
-      if (existsSync3(socketPath)) {
-        this.socket = await connectWithRetry(socketPath, 150);
-      } else {
-        throw new Error("engine socket is absent");
-      }
-    } catch {
-      if (!allowSpawn)
-        return;
-      const nodePath = process.env.KIBI_NODE_PATH ?? "node";
-      const entry = daemonEntry();
-      const lockPath = engineStartLockPath(this.workspaceRoot, this.branch);
-      const startDeadline = Date.now() + this.timeout;
-      let lock = null;
-      while (lock === null && Date.now() < startDeadline) {
-        if (existsSync3(socketPath)) {
-          try {
-            this.socket = await connectWithRetry(socketPath, 100);
-            break;
-          } catch {}
-        }
-        if (this.socket === null) {
-          lock = tryAcquireStartLock(lockPath);
-          if (lock === null) {
-            await new Promise((resolve3) => setTimeout(resolve3, 50));
-          }
-        }
-      }
-      if (this.socket === null && lock === null) {
-        throw new Error(`Unable to connect to Kibi engine at ${socketPath} while another starter owns ${lockPath}`);
-      }
-      if (lock !== null) {
-        try {
-          rmSync(`${socketPath}.error`, { force: true });
-          try {
-            const daemon = spawn2(nodePath, [
-              entry,
-              "--workspace",
-              this.workspaceRoot,
-              "--branch",
-              this.branch,
-              "--socket",
-              socketPath
-            ], {
-              detached: true,
-              stdio: "ignore",
-              env: {
-                ...process.env,
-                KIBI_ENGINE_PROTOCOL: String(ENGINE_PROTOCOL_VERSION)
-              }
-            });
-            await new Promise((resolve3, reject) => {
-              daemon.once("spawn", resolve3);
-              daemon.once("error", reject);
-            });
-            this.daemon = daemon;
-          } catch (error) {
-            throw new Error(`Kibi engine requires Node.js >=18 to host the daemon; failed to start '${nodePath}': ${error instanceof Error ? error.message : String(error)}`);
-          }
-          this.daemon.unref();
-          this.socket = await connectWithRetry(socketPath, this.timeout);
-        } finally {
-          releaseStartLock(lockPath, lock);
-        }
-      }
-    }
-    if (this.socket === null)
-      return;
-    this.attachSocket(this.socket);
-  }
-  attachSocket(socket) {
-    socket.on("data", (chunk) => {
-      try {
-        const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-        this.inputBuffer = parseFrames(Buffer.concat([this.inputBuffer, bytes]), (value) => this.handleResponse(value));
-      } catch (error) {
-        socket.destroy(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-    socket.on("close", () => {
-      this.socket = null;
-      const error = new Error("Kibi engine connection closed");
-      for (const pending of this.pending.values())
-        pending.reject(error);
-      this.pending.clear();
-    });
-    socket.on("error", (error) => {
-      for (const pending of this.pending.values())
-        pending.reject(error);
-      this.pending.clear();
-    });
-  }
-  handleResponse(value) {
-    if (value === null || typeof value !== "object")
-      return;
-    const response = value;
-    if (typeof response.id !== "number")
-      return;
-    const pending = this.pending.get(response.id);
-    if (!pending)
-      return;
-    this.pending.delete(response.id);
-    if (response.ok)
-      pending.resolve(response.result);
-    else
-      pending.reject(new Error(response.error ?? "Kibi engine request failed"));
-  }
-  async request(request, signal) {
-    await this.start();
-    const socket = this.socket;
-    if (socket === null || socket.destroyed)
-      throw new Error("Kibi engine is not connected");
-    const id = ++this.requestId;
-    const result = new Promise((resolve3, reject) => {
-      this.pending.set(id, {
-        resolve: resolve3,
-        reject
-      });
-      try {
-        socket.write(frame({
-          ...request,
-          id,
-          protocolVersion: ENGINE_PROTOCOL_VERSION,
-          packageVersions: ENGINE_PACKAGE_VERSIONS,
-          workspaceRoot: this.workspaceRoot,
-          branch: this.branch
-        }));
-      } catch (error) {
-        this.pending.delete(id);
-        reject(error instanceof Error ? error : new Error(String(error)));
-        return;
-      }
-      if (signal !== undefined) {
-        const abort = () => {
-          if (!this.pending.has(id))
-            return;
-          this.pending.delete(id);
-          this.cancel(id);
-          reject(new Error("Kibi engine request cancelled"));
-        };
-        if (signal.aborted)
-          abort();
-        else
-          signal.addEventListener("abort", abort, { once: true });
-      }
-    });
-    return result;
-  }
-  async query(goal, signal) {
-    let result;
-    const previous = this.requestTail;
-    let release;
-    this.requestTail = new Promise((resolve3) => {
-      release = resolve3;
-    });
-    await previous;
-    try {
-      result = await this.request({ method: "query", goal }, signal);
-      this.lastResult = result;
-      return result;
-    } finally {
-      release();
-    }
-  }
-  async command(command, signal) {
-    return this.request({ method: "command", command }, signal);
-  }
-  async queryBatch(goals) {
-    const normalized = goals.map((goal) => goal.trim().replace(/\.+\s*$/, ""));
-    return this.query(`rdf_transaction((${normalized.join(", ")}))`);
-  }
-  async queryEntities(input, signal) {
-    const result = await this.command({
-      version: 1,
-      kind: "entities",
-      ...input.type !== undefined ? { type: input.type } : {},
-      ...input.id !== undefined ? { id: input.id } : {},
-      ...input.tags !== undefined ? { tags: input.tags } : {},
-      ...input.sourceFile !== undefined ? { sourceFile: input.sourceFile } : {},
-      limit: input.limit,
-      offset: input.offset
-    }, signal);
-    if (!result.success) {
-      throw new Error(result.error ?? "Indexed entity query failed");
-    }
-    const rows = result.bindings.Rows ? parseListOfLists(result.bindings.Rows).map(parseEntityFromList) : [];
-    const count = Number.parseInt(result.bindings.Count ?? "0", 10);
-    return {
-      entities: rows,
-      count: Number.isFinite(count) ? count : rows.length
-    };
-  }
-  async searchEntities(input, signal) {
-    const result = await this.command({
-      version: 1,
-      kind: "search",
-      query: input.query,
-      ...input.type !== undefined ? { type: input.type } : {},
-      limit: input.limit,
-      offset: input.offset
-    }, signal);
-    if (!result.success) {
-      throw new Error(result.error ?? "Indexed search candidate query failed");
-    }
-    const rows = result.bindings.Rows ? parseListOfLists(result.bindings.Rows).map(parseEntityFromList) : [];
-    const count = Number.parseInt(result.bindings.Count ?? "0", 10);
-    return {
-      entities: rows,
-      count: Number.isFinite(count) ? count : rows.length
-    };
-  }
-  cancel(requestId) {
-    const socket = this.socket;
-    if (socket === null || socket.destroyed)
-      return;
-    const id = ++this.requestId;
-    socket.write(frame({
-      id,
-      method: "cancel",
-      cancelOf: requestId,
-      protocolVersion: ENGINE_PROTOCOL_VERSION,
-      packageVersions: ENGINE_PACKAGE_VERSIONS,
-      workspaceRoot: this.workspaceRoot,
-      branch: this.branch
-    }));
-  }
-  async nextSolution() {
-    const result = this.lastResult;
-    this.lastResult = null;
-    return result;
-  }
-  async save(signal) {
-    return this.query("kb_save", signal);
-  }
-  async storageStatus() {
-    return this.request({ method: "status" });
-  }
-  async checkpoint() {
-    return this.command({ version: 1, kind: "checkpoint" });
-  }
-  async queryStatusJson() {
-    return this.command({ version: 1, kind: "status" });
-  }
-  async compact() {
-    return this.command({ version: 1, kind: "compact" });
-  }
-  async exportStorage(targetDirectory) {
-    return this.request({
-      method: "export",
-      targetDirectory
-    });
-  }
-  invalidateCache() {
-    this.lastResult = null;
-  }
-  isRunning() {
-    return this.socket !== null && !this.socket.destroyed;
-  }
-  getPid() {
-    const pidPath = enginePidPath(this.workspaceRoot, this.branch);
-    try {
-      return Number.parseInt(readFileSync2(pidPath, "utf8").trim(), 10) || 0;
-    } catch {
-      return 0;
-    }
-  }
-  async stop(startIfMissing = true) {
-    const socketPath = engineSocketPath(this.workspaceRoot, this.branch);
-    if (!this.isRunning()) {
-      try {
-        await this.start(startIfMissing);
-      } catch {
-        if (!startIfMissing)
-          return;
-        throw new Error("Unable to start Kibi engine for stop request");
-      }
-    }
-    if (!this.isRunning()) {
-      if (existsSync3(socketPath)) {
-        throw new Error(`Kibi engine socket remains present but is not reachable: ${socketPath}`);
-      }
-      return;
-    }
-    let requestError;
-    try {
-      await this.request({ method: "stop" });
-    } catch (error) {
-      requestError = error;
-    }
-    this.socket?.destroy();
-    this.socket = null;
-    const deadline = Date.now() + 5000;
-    while (existsSync3(socketPath) && Date.now() < deadline) {
-      await new Promise((resolve3) => setTimeout(resolve3, 25));
-    }
-    if (existsSync3(socketPath)) {
-      const detail = requestError instanceof Error ? `: ${requestError.message}` : "";
-      throw new Error(`Kibi engine did not stop within 5 seconds${detail}`);
-    }
-  }
-  async terminate() {
-    this.socket?.end();
-    this.socket?.destroy();
-    this.socket = null;
-    this.daemon = null;
-    this.lastResult = null;
-  }
-}
 async function ensureJournaledBranchStoreAsync(branchPath) {
   mkdirSync2(branchPath, { recursive: true });
   const markerPath = path4.join(branchPath, "storage.json");
-  const marker = existsSync3(markerPath) ? readFileSync2(markerPath, "utf8") : "";
+  const marker = existsSync4(markerPath) ? readFileSync3(markerPath, "utf8") : "";
   if (marker.includes("kibi.rdf-journal.v1")) {
     const rdfDirectory = path4.join(branchPath, "rdf");
     const currentPath = path4.join(branchPath, "CURRENT");
     const sentinelPath = path4.join(branchPath, "kb.rdf");
-    if (!existsSync3(rdfDirectory) || !existsSync3(currentPath)) {
+    if (!existsSync4(rdfDirectory) || !existsSync4(currentPath)) {
       recoverInterruptedGeneration(branchPath);
-      if (existsSync3(rdfDirectory) && existsSync3(currentPath)) {
+      if (existsSync4(rdfDirectory) && existsSync4(currentPath)) {
         recoverStaleJournalLock(branchPath);
         archiveLegacyFiles(branchPath);
-        if (!existsSync3(sentinelPath)) {
+        if (!existsSync4(sentinelPath)) {
           writeFileSync2(sentinelPath, `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
         }
         return;
       }
-      const legacyRdf2 = path4.join(branchPath, "kb.rdf");
-      const legacyAudit2 = path4.join(branchPath, "audit.log");
-      const legacyContents = existsSync3(legacyRdf2) ? readFileSync2(legacyRdf2, "utf8") : "";
-      if (existsSync3(legacyAudit2) || existsSync3(legacyRdf2) && !legacyContents.includes("kibi.rdf-journal.v1")) {
-        rmSync(rdfDirectory, { recursive: true, force: true });
-        rmSync(currentPath, { force: true });
-        rmSync(markerPath, { force: true });
+      const legacyRdf = path4.join(branchPath, "kb.rdf");
+      const legacyAudit = path4.join(branchPath, "audit.log");
+      const legacyContents = existsSync4(legacyRdf) ? readFileSync3(legacyRdf, "utf8") : "";
+      if (existsSync4(legacyAudit) || existsSync4(legacyRdf) && !legacyContents.includes("kibi.rdf-journal.v1")) {
+        rmSync2(rdfDirectory, { recursive: true, force: true });
+        rmSync2(currentPath, { force: true });
+        rmSync2(markerPath, { force: true });
       } else {
         throw new Error(`Journaled branch store is incomplete at ${branchPath}; restore the immutable legacy/ backup or remove the interrupted generation before retrying`);
       }
     } else {
       recoverStaleJournalLock(branchPath);
       archiveLegacyFiles(branchPath);
-      if (!existsSync3(sentinelPath)) {
+      if (!existsSync4(sentinelPath)) {
         writeFileSync2(sentinelPath, `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
       }
@@ -1851,7 +1636,7 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
   }
   const legacyRdf = path4.join(branchPath, "kb.rdf");
   const legacyAudit = path4.join(branchPath, "audit.log");
-  if (!existsSync3(legacyRdf) && !existsSync3(legacyAudit)) {
+  if (!existsSync4(legacyRdf) && !existsSync4(legacyAudit)) {
     mkdirSync2(path4.join(branchPath, "rdf"), { recursive: true });
     writeFileSync2(markerPath, `{"format":"kibi.rdf-journal.v1","schemaVersion":1}
 `, { mode: 384 });
@@ -1863,8 +1648,8 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
 `, { mode: 384 });
     return;
   }
-  if (existsSync3(legacyRdf)) {
-    const legacyContents = readFileSync2(legacyRdf, "utf8");
+  if (existsSync4(legacyRdf)) {
+    const legacyContents = readFileSync3(legacyRdf, "utf8");
     if (!/<rdf:RDF(?:\s|>)/.test(legacyContents)) {
       throw new Error(`Legacy Kibi store is corrupt at ${legacyRdf}: expected RDF/XML root`);
     }
@@ -1893,40 +1678,40 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
       throw new Error(migrated.error ?? "Legacy KB migration failed");
     fsyncJournaledBranchStore(staging);
   } catch (error) {
-    rmSync(staging, { recursive: true, force: true });
+    rmSync2(staging, { recursive: true, force: true });
     throw error;
   } finally {
     await migrator.terminate();
   }
   for (const file of ["rdf", "storage.json", "CURRENT"]) {
     const source = path4.join(staging, file);
-    if (!existsSync3(source))
+    if (!existsSync4(source))
       continue;
     const target = path4.join(branchPath, file);
-    if (existsSync3(target))
-      rmSync(target, { recursive: true, force: true });
+    if (existsSync4(target))
+      rmSync2(target, { recursive: true, force: true });
     renameSync(source, target);
   }
   archiveLegacyFiles(branchPath);
   writeFileSync2(path4.join(branchPath, "kb.rdf"), `KIBI_STORAGE_FORMAT=kibi.rdf-journal.v1
 `, { mode: 384 });
   fsyncJournaledBranchStore(branchPath);
-  rmSync(staging, { recursive: true, force: true });
+  rmSync2(staging, { recursive: true, force: true });
 }
 function archiveLegacyFiles(branchPath) {
   const legacyDir = path4.join(branchPath, "legacy");
   mkdirSync2(legacyDir, { recursive: true, mode: 448 });
   for (const file of ["kb.rdf", "audit.log"]) {
     const source = path4.join(branchPath, file);
-    if (!existsSync3(source))
+    if (!existsSync4(source))
       continue;
     if (file === "kb.rdf") {
-      const contents = readFileSync2(source, "utf8");
+      const contents = readFileSync3(source, "utf8");
       if (contents.includes("kibi.rdf-journal.v1"))
         continue;
     }
     const destination = path4.join(legacyDir, file);
-    if (existsSync3(destination)) {
+    if (existsSync4(destination)) {
       renameSync(source, path4.join(legacyDir, `${file}.recovery.${Date.now()}`));
     } else {
       renameSync(source, destination);
@@ -1949,23 +1734,23 @@ function recoverInterruptedGeneration(branchPath) {
   const oldCurrent = newest("CURRENT.old.");
   const rdfPath = path4.join(branchPath, "rdf");
   const currentPath = path4.join(branchPath, "CURRENT");
-  if ((!existsSync3(rdfPath) || !existsSync3(currentPath)) && oldRdf && oldCurrent) {
+  if ((!existsSync4(rdfPath) || !existsSync4(currentPath)) && oldRdf && oldCurrent) {
     try {
-      if (existsSync3(rdfPath))
-        rmSync(rdfPath, { recursive: true, force: true });
-      if (existsSync3(currentPath))
-        rmSync(currentPath, { force: true });
+      if (existsSync4(rdfPath))
+        rmSync2(rdfPath, { recursive: true, force: true });
+      if (existsSync4(currentPath))
+        rmSync2(currentPath, { force: true });
       renameSync(oldRdf, rdfPath);
       renameSync(oldCurrent, currentPath);
       return;
     } catch {}
   }
-  if (!existsSync3(rdfPath) && oldRdf) {
+  if (!existsSync4(rdfPath) && oldRdf) {
     try {
       renameSync(oldRdf, rdfPath);
     } catch {}
   }
-  if (!existsSync3(currentPath) && oldCurrent) {
+  if (!existsSync4(currentPath) && oldCurrent) {
     try {
       renameSync(oldCurrent, currentPath);
     } catch {}
@@ -1980,26 +1765,63 @@ async function runEngineDaemon(options) {
   const prolog = new PrologProcess({ timeout: 120000, oneShot: false });
   await prolog.start();
   const attached = await prolog.query(`kb_attach('${quoteProlog(branchPath)}')`);
-  if (!attached.success)
-    throw new Error(attached.error ?? "Failed to attach branch KB");
-  const statusModulePath = path4.join(path4.dirname(resolveKbPlPath()), "status.pl");
-  const statusLoaded = await prolog.query(`use_module('${quoteProlog(statusModulePath.replaceAll("\\", "/"))}')`);
-  if (!statusLoaded.success) {
-    throw new Error(statusLoaded.error ?? "Failed to load Kibi status module");
+  if (!attached.success) {
+    const recovered = await retryAttachAfterBreakingStaleLock(prolog, branchPath, attached);
+    if (!recovered.success)
+      throw new Error(recovered.error ?? "Failed to attach branch KB");
+  }
+  const attachedIdentity = readEngineAttachmentIdentity(branchPath);
+  const coreModuleDir = path4.dirname(resolveKbPlPath());
+  for (const [fileName, label] of [
+    ["status.pl", "status"],
+    ["discovery.pl", "discovery"]
+  ]) {
+    const modulePath = path4.join(coreModuleDir, fileName);
+    const loaded = await prolog.query(`use_module('${quoteProlog(modulePath.replaceAll("\\", "/"))}')`);
+    if (!loaded.success) {
+      throw new Error(loaded.error ?? `Failed to load Kibi ${label} module`);
+    }
   }
   mkdirSync2(path4.dirname(options.socketPath), { recursive: true, mode: 448 });
-  if (existsSync3(options.socketPath)) {
+  if (existsSync4(options.socketPath)) {
+    const isLivePeerSignal = (error) => {
+      if (error && typeof error === "object") {
+        const code = "code" in error ? String(error.code) : "";
+        if (code === "EPIPE" || code === "ECONNRESET")
+          return true;
+        const errno = "errno" in error ? Number(error.errno) : Number.NaN;
+        if (errno === -32)
+          return true;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return /\bEPIPE\b|\bECONNRESET\b|broken pipe/i.test(message);
+    };
     let live = false;
     try {
       const existing = await connectSocket(options.socketPath, 100);
-      existing.destroy();
+      existing.on("error", () => {
+        return;
+      });
       live = true;
-    } catch {}
+      try {
+        existing.destroy();
+      } catch {}
+      existing.unref?.();
+    } catch (error) {
+      if (isLivePeerSignal(error)) {
+        live = true;
+      }
+    }
     if (live) {
+      try {
+        await prolog.terminate();
+      } catch (error) {
+        if (!isLivePeerSignal(error)) {}
+      }
       throw new Error(`A Kibi engine is already listening at ${options.socketPath}`);
     }
     try {
-      rmSync(options.socketPath, { force: true });
+      rmSync2(options.socketPath, { force: true });
     } catch {}
   }
   writeFileSync2(enginePidPath(options.workspaceRoot, options.branch), `${process.pid}
@@ -2011,7 +1833,6 @@ async function runEngineDaemon(options) {
   let idleCompactionQueued = false;
   const queryCache = new Map;
   let freshnessCache = null;
-  const cancelledRequests = new Set;
   const clients = new Set;
   let shuttingDown = false;
   const exactBranchStatus = (result) => {
@@ -2021,6 +1842,12 @@ async function runEngineDaemon(options) {
     try {
       const decoded = JSON.parse(JSON.parse(result.bindings.JsonString));
       decoded.branch = options.branch;
+      if (attachedIdentity !== null) {
+        decoded.attachedPath = attachedIdentity.path;
+        decoded.attachedGeneration = attachedIdentity.generation;
+        decoded.attachedDev = attachedIdentity.dev;
+        decoded.attachedIno = attachedIdentity.ino;
+      }
       return {
         ...result,
         bindings: {
@@ -2032,6 +1859,21 @@ async function runEngineDaemon(options) {
       return result;
     }
   };
+  let workspaceMissingStreak = 0;
+  const workspaceWatchdog = setInterval(() => {
+    if (shuttingDown)
+      return;
+    if (!existsSync4(options.workspaceRoot)) {
+      workspaceMissingStreak += 1;
+      if (workspaceMissingStreak < 2)
+        return;
+      console.error(`[KIBI] workspace ${options.workspaceRoot} no longer exists; stopping engine`);
+      shutdown();
+      return;
+    }
+    workspaceMissingStreak = 0;
+  }, engineWorkspaceWatchdogMs());
+  workspaceWatchdog.unref();
   const scheduleIdleExit = () => {
     if (activeClients > 0)
       return;
@@ -2054,7 +1896,7 @@ async function runEngineDaemon(options) {
         shutdown();
     }, engineIdleTimeoutMs());
   };
-  const handle = async (request) => {
+  const handle = async (request, cancelledRequests) => {
     if (request.protocolVersion !== ENGINE_PROTOCOL_VERSION) {
       throw new Error(`Kibi engine protocol mismatch: client=${request.protocolVersion ?? "missing"}, server=${ENGINE_PROTOCOL_VERSION}`);
     }
@@ -2276,6 +2118,7 @@ async function runEngineDaemon(options) {
     process.off("SIGINT", requestSignalShutdown);
     if (idleTimer)
       clearTimeout(idleTimer);
+    clearInterval(workspaceWatchdog);
     const saved = await prolog.query("kb_save").catch(() => null);
     if (saved?.success) {
       try {
@@ -2290,23 +2133,22 @@ async function runEngineDaemon(options) {
     server.close();
     server.unref();
     try {
-      if (existsSync3(options.socketPath))
-        rmSync(options.socketPath, { force: true });
-      if (existsSync3(enginePidPath(options.workspaceRoot, options.branch)))
-        rmSync(enginePidPath(options.workspaceRoot, options.branch), {
+      if (existsSync4(options.socketPath))
+        rmSync2(options.socketPath, { force: true });
+      if (existsSync4(enginePidPath(options.workspaceRoot, options.branch)))
+        rmSync2(enginePidPath(options.workspaceRoot, options.branch), {
           force: true
         });
     } catch {}
     setTimeout(() => process.exit(0), 50).unref();
   };
-  const requestSignalShutdown = () => {
-    shutdown();
-  };
+  const requestSignalShutdown = requestEngineSignalShutdown(shutdown);
   process.once("SIGTERM", requestSignalShutdown);
   process.once("SIGINT", requestSignalShutdown);
   server.on("connection", (socket) => {
     clients.add(socket);
     activeClients += 1;
+    const cancelledRequests = new Set;
     let buffer = Buffer.alloc(0);
     socket.on("data", (chunk) => {
       try {
@@ -2327,7 +2169,7 @@ async function runEngineDaemon(options) {
               return;
             }
             try {
-              const result = await handle(request);
+              const result = await handle(request, cancelledRequests);
               writeSocketFrame(socket, {
                 id: request.id,
                 ok: true,
@@ -2341,6 +2183,8 @@ async function runEngineDaemon(options) {
                 error: error instanceof Error ? error.message : String(error),
                 serverPackageVersions: ENGINE_PACKAGE_VERSIONS
               });
+            } finally {
+              cancelledRequests.delete(request.id);
             }
           }).catch(() => {
             return;
@@ -2356,9 +2200,9 @@ async function runEngineDaemon(options) {
       scheduleIdleExit();
     });
   });
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve, reject) => {
     server.once("error", reject);
-    server.listen(options.socketPath, () => resolve3());
+    server.listen(options.socketPath, () => resolve());
   });
   if (process.platform !== "win32") {
     try {
@@ -2366,12 +2210,25 @@ async function runEngineDaemon(options) {
     } catch {}
   }
   scheduleIdleExit();
-  await new Promise((resolve3) => {
-    server.once("close", resolve3);
+  await new Promise((resolve) => {
+    server.once("close", resolve);
   });
 }
 
 // ../cli/src/engine-daemon.ts
+function isEngineDaemonEntrypoint(argv = process.argv, moduleUrl = import.meta.url, isMain = __require.main == __require.module) {
+  if (isMain === true) {
+    return moduleUrl === import.meta.url;
+  }
+  const entry = argv[1];
+  if (typeof entry !== "string" || entry.length === 0)
+    return false;
+  try {
+    return moduleUrl === pathToFileURL(path5.resolve(entry)).href;
+  } catch {
+    return false;
+  }
+}
 function requiredArg(args, name) {
   const index = args.indexOf(name);
   const value = index >= 0 ? args[index + 1] : undefined;
@@ -2380,23 +2237,35 @@ function requiredArg(args, name) {
   }
   return value;
 }
-var args = process.argv.slice(2);
-try {
-  await runEngineDaemon({
-    workspaceRoot: requiredArg(args, "--workspace"),
-    branch: requiredArg(args, "--branch"),
-    socketPath: requiredArg(args, "--socket")
-  });
-} catch (error) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(message);
-  const socketIndex = args.indexOf("--socket");
-  const socketPath = socketIndex >= 0 ? args[socketIndex + 1] : undefined;
-  if (socketPath) {
-    try {
-      writeFileSync3(`${socketPath}.error`, `${message}
+async function runEngineDaemonCli(args = process.argv.slice(2)) {
+  try {
+    await runEngineDaemon({
+      workspaceRoot: requiredArg(args, "--workspace"),
+      branch: requiredArg(args, "--branch"),
+      socketPath: requiredArg(args, "--socket")
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    const socketIndex = args.indexOf("--socket");
+    const socketPath = socketIndex >= 0 ? args[socketIndex + 1] : undefined;
+    if (socketPath) {
+      try {
+        writeFileSync3(`${socketPath}.error`, `${message}
 `, { mode: 384 });
-    } catch {}
+      } catch {}
+    }
+    process.exitCode = 1;
   }
-  process.exitCode = 1;
 }
+async function runEngineDaemonIfEntrypoint(isEntrypoint = isEngineDaemonEntrypoint()) {
+  if (!isEntrypoint)
+    return;
+  await runEngineDaemonCli();
+}
+await runEngineDaemonIfEntrypoint();
+export {
+  isEngineDaemonEntrypoint,
+  runEngineDaemonCli,
+  runEngineDaemonIfEntrypoint
+};