kibi-runtime 1.0.1 → 2.0.0

package/dist/engine-daemon.js

@@ -1,7 +1,11 @@
 #!/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";
@@ -9,15 +13,15 @@ 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
@@ -30,7 +34,7 @@ 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 +50,646 @@ 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 parseListOfLists(listStr) {
+  return parseListRows(listStr).flatMap((row) => {
+    const scanned = scanTopLevelGeneral(row, ",");
+    if (!scanned.balanced)
+      return [];
+    const columns = scanned.parts.map((column) => column.trim());
+    return columns.length === 0 || columns.length === 1 && columns[0] === "" ? [] : [columns];
+  });
+}
+function firstTwoDefinedParts(parts) {
+  const first = parts[0];
+  const second = parts[1];
+  if (first === undefined || second === undefined) {
+    return;
+  }
+  return [first, second];
+}
+function typedLiteralFromParts(parts, original) {
+  const pair = firstTwoDefinedParts(parts);
+  if (!pair) {
+    return original;
+  }
+  const [literalPart, datatypePart] = pair;
+  let literalValue = literalPart.trim();
+  const datatype = datatypePart.trim();
+  const decodedLiteral = decodePrologQuotedLiteral(literalValue, '"');
+  if (decodedLiteral !== undefined) {
+    literalValue = decodedLiteral;
+  } else 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;
+}
+function fileUriLeaf(value) {
+  const lastSlash = value.lastIndexOf("/");
+  if (lastSlash !== -1) {
+    return value.substring(lastSlash + 1);
+  }
+  return value;
+}
+function parseEntityFromList(data) {
+  if (data.length < 3) {
+    return {};
+  }
+  const [idPart, typePart, propsPart] = data;
+  if (idPart === undefined || typePart === undefined || propsPart === undefined) {
+    return {};
+  }
+  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 === "proof_receipts" || key === "proof_contract" || key === "proof_bindings") && 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) {
+      return typedLiteralFromParts(parts, value);
+    }
+  }
+  if (value.startsWith("file:///")) {
+    return fileUriLeaf(value);
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return decodePrologQuotedLiteral(value, '"') ?? value.substring(1, value.length - 1);
+  }
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return decodePrologQuotedLiteral(value, "'") ?? 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 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
+  };
+}
+function stripOuterQuotes(value) {
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return decodePrologQuotedLiteral(value, "'") ?? value.slice(1, -1);
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return decodePrologQuotedLiteral(value, '"') ?? value.slice(1, -1);
+  }
+  return value;
+}
+function normalizeEntityId(value) {
+  if (value.startsWith("kb:entity/")) {
+    return value.slice("kb:entity/".length);
+  }
+  if (!value.startsWith("file:///")) {
+    return value;
+  }
+  const idx = value.lastIndexOf("/");
+  return idx === -1 ? value : value.slice(idx + 1);
+}
+function parseListRows(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "[]" || trimmed.length === 0) {
+    return [];
+  }
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+    return [];
+  }
+  const content = unwrapList(trimmed);
+  if (content.length === 0) {
+    return [];
+  }
+  const scanned = scanTopLevelGeneral(content, ",");
+  if (!scanned.balanced) {
+    return [];
+  }
+  const rows = [];
+  for (const term of scanned.parts) {
+    const row = term.trim();
+    if (row.length === 0)
+      continue;
+    if (!row.startsWith("[") || !row.endsWith("]")) {
+      return [];
+    }
+    rows.push(row.slice(1, -1).trim());
+  }
+  return rows;
+}
+function unwrapList(value) {
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return value.slice(1, -1).trim();
+  }
+  return value;
+}
+function decodePrologQuotedLiteral(value, quote) {
+  if (!value.startsWith(quote) || !value.endsWith(quote) || value.length < 2) {
+    return;
+  }
+  const content = value.slice(1, -1);
+  let decoded = "";
+  for (let index = 0;index < content.length; index++) {
+    const char = content[index];
+    if (char === undefined)
+      continue;
+    if (quote === "'" && char === "'") {
+      if (content[index + 1] !== "'")
+        return;
+      decoded += "'";
+      index++;
+      continue;
+    }
+    if (char !== "\\") {
+      decoded += char;
+      continue;
+    }
+    const escaped = content[index + 1];
+    if (escaped === undefined)
+      return;
+    index++;
+    switch (escaped) {
+      case "a":
+        decoded += "\x07";
+        break;
+      case "b":
+        decoded += "\b";
+        break;
+      case "e":
+        decoded += "\x1B";
+        break;
+      case "f":
+        decoded += "\f";
+        break;
+      case "n":
+        decoded += `
+`;
+        break;
+      case "r":
+        decoded += "\r";
+        break;
+      case "t":
+        decoded += "\t";
+        break;
+      case "v":
+        decoded += "\v";
+        break;
+      case "\\":
+        decoded += "\\";
+        break;
+      case "'":
+        decoded += "'";
+        break;
+      case '"':
+        decoded += '"';
+        break;
+      case "u": {
+        const code = content.slice(index + 1, index + 5);
+        if (!/^[0-9A-Fa-f]{4}$/.test(code))
+          return;
+        decoded += String.fromCodePoint(Number.parseInt(code, 16));
+        index += 4;
+        break;
+      }
+      case "U": {
+        const code = content.slice(index + 1, index + 9);
+        if (!/^[0-9A-Fa-f]{8}$/.test(code))
+          return;
+        const codePoint = Number.parseInt(code, 16);
+        if (codePoint > 1114111)
+          return;
+        decoded += String.fromCodePoint(codePoint);
+        index += 8;
+        break;
+      }
+      case "x": {
+        let end = index + 1;
+        while (/[0-9A-Fa-f]/.test(content[end] ?? ""))
+          end++;
+        if (end === index + 1 || content[end] !== "\\")
+          return;
+        const codePoint = Number.parseInt(content.slice(index + 1, end), 16);
+        if (codePoint > 1114111)
+          return;
+        decoded += String.fromCodePoint(codePoint);
+        index = end;
+        break;
+      }
+      default:
+        return;
+    }
+  }
+  return decoded;
+}
+
+// ../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 message2 = unquoteAtom(contextRaw.trim());
+    return message2 === "" ? null : { message: message2 };
+  }
+  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 +727,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 +760,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 +793,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 +856,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 +869,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 +914,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 +1042,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 +1155,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 +1274,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 = {};
@@ -639,315 +1291,204 @@ writeln('${INTERACTIVE_QUERY_FRAME_END}').
     for (const line of output.split(`
 `)) {
       const match = line.match(/^([A-Z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
-      if (match?.[1] !== undefined && match[2] !== undefined) {
-        flush();
-        variableName = match[1];
-        valueLines = [match[2]];
-        continue;
-      }
-      if (variableName !== undefined)
-        valueLines.push(line);
-    }
-    flush();
-    return bindings;
-  }
-  translateError(errorText) {
-    const cleanError = errorText.replace(/^__KIBI_(?:STAGE|RUNTIME)__:[^\r\n]*\r?\n?/gm, "");
-    if (cleanError.includes("stale_snapshot")) {
-      return "KB snapshot is stale; reattach or refresh the runtime before retrying (stale_snapshot)";
-    }
-    if ((cleanError.includes("audit_log") || cleanError.includes("audit.log") || cleanError.includes("Resource temporarily unavailable")) && (cleanError.includes("lock") || cleanError.includes("permission"))) {
-      return "Audit journal is locked by another Kibi runtime; restart the stale MCP/CLI session before retrying";
-    }
-    if (cleanError.includes("does not exist") && /entity [`'"].+?[`'"]/.test(cleanError)) {
-      const entityIdMatch = cleanError.match(/entity [`'"]+(.+?)[`'"]+ does not exist/);
-      const matchedEntityId = entityIdMatch?.[1];
-      const entityId = matchedEntityId !== undefined ? matchedEntityId.replace(/^`?'+|'+`?$/g, "") : "unknown";
-      if (cleanError.includes("Target entity does not exist")) {
-        return `Target entity does not exist: ${entityId}`;
-      }
-      if (cleanError.includes("Source entity does not exist")) {
-        return `Source entity does not exist: ${entityId}`;
-      }
-      return `Entity does not exist: ${entityId}`;
-    }
-    if (cleanError.includes("Type error: `relationship' expected")) {
-      const relMatch = cleanError.match(/\(Invalid relationship: ([^)]+)\)/);
-      const invalidRelationship = relMatch?.[1];
-      if (invalidRelationship !== undefined) {
-        return `Invalid relationship: ${invalidRelationship.trim()}`;
-      }
-      return "Invalid relationship type or direction";
-    }
-    if (cleanError.includes("existence_error") || cleanError.includes("Unknown procedure")) {
-      return "Predicate or file not found";
-    }
-    if (cleanError.includes("permission_error")) {
-      return "Access denied or KB locked";
-    }
-    if (cleanError.includes("syntax_error") || cleanError.includes("Operator expected")) {
-      return "Invalid query syntax";
-    }
-    if (cleanError.includes("timeout_error")) {
-      return `Operation exceeded ${this.timeout / 1000}s timeout`;
-    }
-    const simpleError = (cleanError.replace(/ERROR:\s*/g, "").replace(/^\*\*.*\*\*$/gm, "").replace(/^\s+/gm, "").split(`
-`)[0] ?? "").trim();
-    return simpleError || "Unknown error";
-  }
-  isRunning() {
-    return Boolean(this.process && !this.process.killed && this.process?.exitCode === null);
-  }
-  getPid() {
-    return this.process?.pid || 0;
-  }
-  async terminate() {
-    if (this.terminationPromise) {
-      await this.terminationPromise;
-      return;
-    }
-    if (this.onProcessExit) {
-      process.off("exit", this.onProcessExit);
-      this.onProcessExit = null;
-    }
-    const current = this.process;
-    const oneShots = [...this.oneShotProcesses];
-    this.process = null;
-    this.clearQueryBuffers();
-    if (current || oneShots.length > 0) {
-      this.terminationPromise = (async () => {
-        if (current) {
-          current.stdin?.end();
-          await this.terminateProcessTree(current);
-        }
-        await Promise.all(oneShots.map((child) => this.terminateProcessTree(child)));
-      })();
-      try {
-        await this.terminationPromise;
-      } finally {
-        this.terminationPromise = null;
-      }
-    }
-  }
-}
-
-// ../cli/src/prolog/codec.ts
-function parseListOfLists(listStr) {
-  const cleaned = listStr.trim().replace(/^\[/, "").replace(/\]$/, "");
-  if (cleaned === "") {
-    return [];
-  }
-  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;
-    }
-  }
-  return results;
-}
-function parseEntityFromList(data) {
-  if (data.length < 3) {
-    return {};
-  }
-  const [idPart, typePart, propsPart] = data;
-  if (idPart === undefined || typePart === undefined || propsPart === undefined) {
-    return {};
-  }
-  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;
-        }
+      if (match?.[1] !== undefined && match[2] !== undefined) {
+        flush();
+        variableName = match[1];
+        valueLines = [match[2]];
+        continue;
       }
+      if (variableName !== undefined)
+        valueLines.push(line);
     }
-    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);
+    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|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)";
+    }
+    if ((cleanError.includes("audit_log") || cleanError.includes("audit.log") || cleanError.includes("Resource temporarily unavailable")) && (cleanError.includes("lock") || cleanError.includes("permission"))) {
+      return "Audit journal is locked by another Kibi runtime; restart the stale MCP/CLI session before retrying";
+    }
+    if (cleanError.includes("does not exist") && /entity [`'"].+?[`'"]/.test(cleanError)) {
+      const entityIdMatch = cleanError.match(/entity [`'"]+(.+?)[`'"]+ does not exist/);
+      const matchedEntityId = entityIdMatch?.[1];
+      const entityId = matchedEntityId !== undefined ? matchedEntityId.replace(/^`?'+|'+`?$/g, "") : "unknown";
+      if (cleanError.includes("Target entity does not exist")) {
+        return `Target entity does not exist: ${entityId}`;
       }
-      if (datatype.includes("#boolean")) {
-        return literalValue === "true";
+      if (cleanError.includes("Source entity does not exist")) {
+        return `Source entity does not exist: ${entityId}`;
       }
-      if (literalValue.startsWith("[") && literalValue.endsWith("]")) {
-        const listContent = literalValue.substring(1, literalValue.length - 1);
-        if (listContent === "") {
-          return [];
-        }
-        return splitTopLevelGeneral(listContent, ",").map((item) => item.trim());
+      return `Entity does not exist: ${entityId}`;
+    }
+    if (cleanError.includes("Type error: `relationship' expected")) {
+      const relMatch = cleanError.match(/\(Invalid relationship: ([^)]+)\)/);
+      const invalidRelationship = relMatch?.[1];
+      if (invalidRelationship !== undefined) {
+        return `Invalid relationship: ${invalidRelationship.trim()}`;
       }
-      return literalValue;
+      return "Invalid relationship type or direction";
     }
-  }
-  if (value.startsWith("file:///")) {
-    const lastSlash = value.lastIndexOf("/");
-    if (lastSlash !== -1) {
-      return value.substring(lastSlash + 1);
+    if (cleanError.includes("existence_error") || cleanError.includes("Unknown procedure")) {
+      return "Predicate or file not found";
     }
-    return value;
-  }
-  if (value.startsWith('"') && value.endsWith('"')) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value.substring(1, value.length - 1);
+    if (cleanError.includes("permission_error")) {
+      return "Access denied or KB locked";
+    }
+    if (cleanError.includes("syntax_error") || cleanError.includes("Operator expected")) {
+      return "Invalid query syntax";
     }
+    if (cleanError.includes("timeout_error")) {
+      return `Operation exceeded ${this.timeout / 1000}s timeout`;
+    }
+    const simpleError = (cleanError.replace(/ERROR:\s*/g, "").replace(/^\*\*.*\*\*$/gm, "").replace(/^\s+/gm, "").split(`
+`)[0] ?? "").trim();
+    return simpleError || "Unknown error";
   }
-  if (value.startsWith("'") && value.endsWith("'")) {
-    return value.substring(1, value.length - 1);
+  isRunning() {
+    return Boolean(this.process && !this.process.killed && this.process?.exitCode === null && this.process?.signalCode === null);
   }
-  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;
+  getPid() {
+    return this.process?.pid || 0;
   }
-  return value;
-}
-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 = "";
+  async terminate() {
+    if (this.terminationPromise) {
+      await this.terminationPromise;
+      return;
+    }
+    if (this.onProcessExit) {
+      process.off("exit", this.onProcessExit);
+      this.onProcessExit = null;
+    }
+    const current = this.process;
+    const oneShots = [...this.oneShotProcesses];
+    this.process = null;
+    this.clearQueryBuffers();
+    if (current || oneShots.length > 0) {
+      this.terminationPromise = (async () => {
+        if (current) {
+          current.stdin?.end();
+          await this.terminateProcessTree(current);
+        }
+        await Promise.all(oneShots.map((child) => this.terminateProcessTree(child)));
+      })();
+      try {
+        await this.terminationPromise;
+      } finally {
+        this.terminationPromise = null;
       }
-    } else {
-      current += char;
     }
   }
-  if (current) {
-    results.push(current);
+}
+
+// ../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;
   }
-  return results;
+  try {
+    const raw = readFileSync("/proc/sys/kernel/random/boot_id", "utf8");
+    cachedBootId = raw.trim();
+  } catch {
+    cachedBootId = null;
+  }
+  return cachedBootId;
 }
-function stripOuterQuotes(value) {
-  if (value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
+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";
   }
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return value.slice(1, -1);
+}
+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 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 });
+    }
   }
-  return value;
 }
-function normalizeEntityId(value) {
-  if (!value.startsWith("file:///")) {
-    return value;
+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}` : ""}`
+      };
   }
-  const idx = value.lastIndexOf("/");
-  return idx === -1 ? value : value.slice(idx + 1);
+}
+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.`);
+  }
+  return retried;
 }
 
 // ../cli/src/utils/branch-resolver.ts
@@ -960,9 +1501,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 +1531,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 +1561,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);
@@ -1083,10 +1624,78 @@ 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 parseEngineAttachmentIdentity(statusJson) {
+  if (statusJson === undefined)
+    return null;
+  try {
+    const decoded = JSON.parse(JSON.parse(statusJson));
+    if (typeof decoded.attachedPath !== "string" || typeof decoded.attachedGeneration !== "string" || typeof decoded.attachedDev !== "number" || typeof decoded.attachedIno !== "number") {
+      return null;
+    }
+    return {
+      path: decoded.attachedPath,
+      generation: decoded.attachedGeneration,
+      dev: decoded.attachedDev,
+      ino: decoded.attachedIno
+    };
+  } catch {
+    return null;
+  }
+}
+function engineAttachmentsMatch(expected, attached) {
+  if (expected === null || attached === null)
+    return false;
+  if (expected.path !== attached.path)
+    return false;
+  if (expected.ino !== 0 && attached.ino !== 0) {
+    return expected.dev === attached.dev && expected.ino === attached.ino;
+  }
+  return expected.generation.length > 0 && expected.generation === attached.generation;
+}
+function formatEngineAttachmentMismatch(operation, expected, attached) {
+  return [
+    `operation=${operation}`,
+    `branchStore=${expected?.path ?? "missing"}`,
+    `expectedGeneration=${expected?.generation || "missing"}`,
+    `attachedPath=${attached?.path ?? "missing"}`,
+    `attachedGeneration=${attached?.generation || "missing"}`
+  ].join(" ");
+}
 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 +1824,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 +1838,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)
@@ -1284,7 +1893,7 @@ function enginePublicationLockPath(workspaceRoot, branch) {
 }
 function publicationLockOwner(lockPath) {
   try {
-    const [pidText, createdText] = readFileSync2(lockPath, "utf8").trim().split(":");
+    const [pidText, createdText] = readFileSync3(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)) {
@@ -1304,7 +1913,7 @@ function processIsAlive(pid) {
   }
 }
 function clearStalePublicationLock(lockPath) {
-  if (!existsSync3(lockPath))
+  if (!existsSync4(lockPath))
     return true;
   const owner = publicationLockOwner(lockPath);
   let age = 0;
@@ -1324,11 +1933,11 @@ function clearStalePublicationLock(lockPath) {
   return false;
 }
 function publicationLockIsActive(lockPath) {
-  if (!existsSync3(lockPath))
+  if (!existsSync4(lockPath))
     return false;
   if (clearStalePublicationLock(lockPath))
     return false;
-  return existsSync3(lockPath);
+  return existsSync4(lockPath);
 }
 function tryAcquireStartLock(lockPath) {
   try {
@@ -1338,7 +1947,7 @@ function tryAcquireStartLock(lockPath) {
     return descriptor;
   } catch {
     try {
-      const stamp = readFileSync2(lockPath, "utf8").trim().split(":");
+      const stamp = readFileSync3(lockPath, "utf8").trim().split(":");
       const pid = Number.parseInt(stamp[0] ?? "", 10);
       const created = Number.parseInt(stamp[1] ?? "", 10);
       let age = 0;
@@ -1377,11 +1986,11 @@ function releaseStartLock(lockPath, descriptor) {
 }
 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,7 +2005,7 @@ function recoverStaleJournalLock(branchPath) {
     return;
   } catch {
     try {
-      rmSync(lockPath, { force: true });
+      rmSync2(lockPath, { force: true });
     } catch {}
   }
 }
@@ -1408,7 +2017,7 @@ function daemonEntry() {
     path4.join(moduleDirectory, "..", "node_modules", "kibi-cli", "dist", "engine-daemon.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate))
+    if (existsSync4(candidate))
       return candidate;
   }
   throw new Error("The Kibi engine is not built. Run `npm run build:cli` before using the CLI engine.");
@@ -1445,16 +2054,16 @@ async function connectWithRetry(socketPath, timeoutMs) {
   let lastError;
   while (Date.now() < deadline) {
     const errorPath = `${socketPath}.error`;
-    if (existsSync3(errorPath)) {
+    if (existsSync4(errorPath)) {
       try {
-        const diagnostic = readFileSync2(errorPath, "utf8").trim();
+        const diagnostic = readFileSync3(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)) {
+    if (process.platform !== "win32" && !existsSync4(socketPath)) {
       await new Promise((resolve3) => setTimeout(resolve3, 25));
       continue;
     }
@@ -1480,6 +2089,7 @@ class EngineClient {
   pending = new Map;
   requestTail = Promise.resolve();
   lastResult = null;
+  replacingStaleDaemon = false;
   constructor(options) {
     if (!isValidBranchName(options.branch)) {
       throw new Error(`Invalid Kibi engine branch name: ${options.branch}`);
@@ -1495,6 +2105,13 @@ class EngineClient {
     this.allowPublicationLock = options.allowPublicationLock ?? false;
   }
   async start(allowSpawn = true) {
+    const wasConnected = this.socket !== null && !this.socket.destroyed;
+    await this.connect(allowSpawn);
+    if (!wasConnected && this.socket !== null) {
+      await this.reconcileAttachment();
+    }
+  }
+  async connect(allowSpawn = true) {
     if (this.socket !== null && !this.socket.destroyed)
       return;
     const socketPath = engineSocketPath(this.workspaceRoot, this.branch);
@@ -1503,7 +2120,7 @@ class EngineClient {
       throw new Error(`Kibi engine publication is in progress: ${publicationLockPath}`);
     }
     try {
-      if (existsSync3(socketPath)) {
+      if (existsSync4(socketPath)) {
         this.socket = await connectWithRetry(socketPath, 150);
       } else {
         throw new Error("engine socket is absent");
@@ -1517,7 +2134,7 @@ class EngineClient {
       const startDeadline = Date.now() + this.timeout;
       let lock = null;
       while (lock === null && Date.now() < startDeadline) {
-        if (existsSync3(socketPath)) {
+        if (existsSync4(socketPath)) {
           try {
             this.socket = await connectWithRetry(socketPath, 100);
             break;
@@ -1535,7 +2152,7 @@ class EngineClient {
       }
       if (lock !== null) {
         try {
-          rmSync(`${socketPath}.error`, { force: true });
+          rmSync2(`${socketPath}.error`, { force: true });
           try {
             const daemon = spawn2(nodePath, [
               entry,
@@ -1760,27 +2377,37 @@ class EngineClient {
   isRunning() {
     return this.socket !== null && !this.socket.destroyed;
   }
-  getPid() {
-    const pidPath = enginePidPath(this.workspaceRoot, this.branch);
+  async readAttachedIdentity() {
+    const status = await this.queryStatusJson();
+    if (!status.success)
+      return null;
+    return parseEngineAttachmentIdentity(status.bindings.JsonString);
+  }
+  async reconcileAttachment() {
+    if (this.replacingStaleDaemon || this.socket === null)
+      return;
+    const livePath = branchStorePath(this.workspaceRoot, this.branch);
+    const expected = readEngineAttachmentIdentity(livePath);
+    const attached = await this.readAttachedIdentity();
+    if (engineAttachmentsMatch(expected, attached))
+      return;
+    this.replacingStaleDaemon = true;
     try {
-      return Number.parseInt(readFileSync2(pidPath, "utf8").trim(), 10) || 0;
-    } catch {
-      return 0;
+      await this.shutdownConnectedDaemon();
+      await this.connect(true);
+      const live = readEngineAttachmentIdentity(livePath);
+      const retried = await this.readAttachedIdentity();
+      if (!engineAttachmentsMatch(live, retried)) {
+        throw new Error(`Kibi engine is attached to a stale branch generation: ${formatEngineAttachmentMismatch("attachment-handshake", live, retried)}`);
+      }
+    } finally {
+      this.replacingStaleDaemon = false;
     }
   }
-  async stop(startIfMissing = true) {
+  async shutdownConnectedDaemon() {
     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)) {
+      if (existsSync4(socketPath)) {
         throw new Error(`Kibi engine socket remains present but is not reachable: ${socketPath}`);
       }
       return;
@@ -1794,14 +2421,41 @@ class EngineClient {
     this.socket?.destroy();
     this.socket = null;
     const deadline = Date.now() + 5000;
-    while (existsSync3(socketPath) && Date.now() < deadline) {
+    while (existsSync4(socketPath) && Date.now() < deadline) {
       await new Promise((resolve3) => setTimeout(resolve3, 25));
     }
-    if (existsSync3(socketPath)) {
+    if (existsSync4(socketPath)) {
       const detail = requestError instanceof Error ? `: ${requestError.message}` : "";
       throw new Error(`Kibi engine did not stop within 5 seconds${detail}`);
     }
   }
+  getPid() {
+    const pidPath = enginePidPath(this.workspaceRoot, this.branch);
+    try {
+      return Number.parseInt(readFileSync3(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.connect(startIfMissing);
+      } catch {
+        if (!startIfMissing)
+          return;
+        throw new Error("Unable to start Kibi engine for stop request");
+      }
+    }
+    if (!this.isRunning()) {
+      if (existsSync4(socketPath)) {
+        throw new Error(`Kibi engine socket remains present but is not reachable: ${socketPath}`);
+      }
+      return;
+    }
+    await this.shutdownConnectedDaemon();
+  }
   async terminate() {
     this.socket?.end();
     this.socket?.destroy();
@@ -1813,17 +2467,17 @@ class EngineClient {
 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 });
         }
@@ -1831,18 +2485,18 @@ async function ensureJournaledBranchStoreAsync(branchPath) {
       }
       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 legacyContents = existsSync4(legacyRdf2) ? readFileSync3(legacyRdf2, "utf8") : "";
+      if (existsSync4(legacyAudit2) || existsSync4(legacyRdf2) && !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 +2505,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 +2517,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 +2547,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 +2603,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,15 +2634,25 @@ 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)) {
     let live = false;
     try {
       const existing = await connectSocket(options.socketPath, 100);
@@ -1999,7 +2663,7 @@ async function runEngineDaemon(options) {
       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}
@@ -2021,6 +2685,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 +2702,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;
@@ -2276,6 +2961,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,18 +2976,16 @@ 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) => {
@@ -2372,6 +3056,19 @@ async function runEngineDaemon(options) {
 }
 
 // ../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 +3077,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 {
+  runEngineDaemonIfEntrypoint,
+  runEngineDaemonCli,
+  isEngineDaemonEntrypoint
+};